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 // add here SWIG version check
 473
 474 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 475 // disable Swig-dependent warnings
 476
 477 // 'identifier1' has C-linkage specified,
 478 // but returns UDT 'identifier2' which is incompatible with C
 479 #pragma warning(disable: 4190)
 480
 481 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 482 #pragma warning(disable: 4800)
 483
 484 // debug info too long etc etc
 485 #pragma warning(disable: 4786)
 486 #endif
 487
 488
 489 #include <stdexcept>
 490
 491
 492 #include <string>
 493
 494
 495 #include <vector>
 496 #include <algorithm>
 497 #include <stdexcept>
 498
 499
 500 #include <map>
 501 #include <algorithm>
 502 #include <stdexcept>
 503
 504
 505 #include <utility>
 506
 507
 508 typedef float floatp;
 509
 510 SWIGINTERN floatp *new_floatp(){
 511   return new float();
 512 }
 513 SWIGINTERN void delete_floatp(floatp *self){
 514   if (self) delete self;
 515 }
 516 SWIGINTERN void floatp_assign(floatp *self,float value){
 517   *self = value;
 518 }
 519 SWIGINTERN float floatp_value(floatp *self){
 520   return *self;
 521 }
 522 SWIGINTERN float *floatp_cast(floatp *self){
 523   return self;
 524 }
 525 SWIGINTERN floatp *floatp_frompointer(float *t){
 526   return (floatp *) t;
 527 }
 528
 529 typedef int intp;
 530
 531 SWIGINTERN intp *new_intp(){
 532   return new int();
 533 }
 534 SWIGINTERN void delete_intp(intp *self){
 535   if (self) delete self;
 536 }
 537 SWIGINTERN void intp_assign(intp *self,int value){
 538   *self = value;
 539 }
 540 SWIGINTERN int intp_value(intp *self){
 541   return *self;
 542 }
 543 SWIGINTERN int *intp_cast(intp *self){
 544   return self;
 545 }
 546 SWIGINTERN intp *intp_frompointer(int *t){
 547   return (intp *) t;
 548 }
 549
 550 typedef double doublep;
 551
 552 SWIGINTERN doublep *new_doublep(){
 553   return new double();
 554 }
 555 SWIGINTERN void delete_doublep(doublep *self){
 556   if (self) delete self;
 557 }
 558 SWIGINTERN void doublep_assign(doublep *self,double value){
 559   *self = value;
 560 }
 561 SWIGINTERN double doublep_value(doublep *self){
 562   return *self;
 563 }
 564 SWIGINTERN double *doublep_cast(doublep *self){
 565   return self;
 566 }
 567 SWIGINTERN doublep *doublep_frompointer(double *t){
 568   return (doublep *) t;
 569 }
 570
 571 typedef unsigned int uintp;
 572
 573 SWIGINTERN uintp *new_uintp(){
 574   return new unsigned int();
 575 }
 576 SWIGINTERN void delete_uintp(uintp *self){
 577   if (self) delete self;
 578 }
 579 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 580   *self = value;
 581 }
 582 SWIGINTERN unsigned int uintp_value(uintp *self){
 583   return *self;
 584 }
 585 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 586   return self;
 587 }
 588 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 589   return (uintp *) t;
 590 }
 591
 592 typedef unsigned short ushortp;
 593
 594 SWIGINTERN ushortp *new_ushortp(){
 595   return new unsigned short();
 596 }
 597 SWIGINTERN void delete_ushortp(ushortp *self){
 598   if (self) delete self;
 599 }
 600 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 601   *self = value;
 602 }
 603 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 604   return *self;
 605 }
 606 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 607   return self;
 608 }
 609 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 610   return (ushortp *) t;
 611 }
 612
 613 unsigned int int_to_uint(int x) {
 614    return (unsigned int) x;
 615 }
 616
 617
 618 using namespace Dali;
 619 using namespace Dali::Toolkit;
 620
 621 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 622 {
 623   bool result = false;
 624   try
 625   {
 626     // C++ code. DALi uses Handle <-> Body design pattern.
 627     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 628     // Handles in DALi can be converted into a boolean type
 629     // to check if the handle has a valid body attached to it.
 630     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 631     if( *self )
 632     {
 633       result = true;
 634     }
 635     else
 636     {
 637       result = false;
 638     }
 639   }
 640   catch (std::out_of_range& e)
 641   {
 642     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 643     return 0;
 644   }
 645   catch (std::exception& e)
 646   {
 647     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 648     return 0;
 649   }
 650   catch (DaliException e)
 651   {
 652     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 653     return 0;
 654   }
 655   catch (...)
 656   {
 657     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 658     return 0;
 659   }
 660   return result;
 661 }
 662
 663 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 664 {
 665   bool result = false;
 666   try
 667   {
 668     // C++ code. Check if two handles reference the same implemtion
 669     if( *self == rhs)
 670     {
 671       result = true;
 672     }
 673     else
 674     {
 675       result = false;
 676     }
 677   }
 678   catch (std::out_of_range& e)
 679   {
 680     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 681     return 0;
 682   }
 683   catch (std::exception& e)
 684   {
 685     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 686     return 0;
 687   }
 688   catch (DaliException e)
 689   {
 690     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 691     return 0;
 692   }
 693   catch (...)
 694   {
 695     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 696     return 0;
 697   }
 698   return result;
 699 }
 700
 701
 702 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 703      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 704    }
 705 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){
 706      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 707    }
 708 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 709         std::vector< Dali::TouchPoint >* pv = 0;
 710         if (capacity >= 0) {
 711           pv = new std::vector< Dali::TouchPoint >();
 712           pv->reserve(capacity);
 713        } else {
 714           throw std::out_of_range("capacity");
 715        }
 716        return pv;
 717       }
 718 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 719         if (index>=0 && index<(int)self->size())
 720           return (*self)[index];
 721         else
 722           throw std::out_of_range("index");
 723       }
 724 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 725         if (index>=0 && index<(int)self->size())
 726           return (*self)[index];
 727         else
 728           throw std::out_of_range("index");
 729       }
 730 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 731         if (index>=0 && index<(int)self->size())
 732           (*self)[index] = val;
 733         else
 734           throw std::out_of_range("index");
 735       }
 736 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 737         self->insert(self->end(), values.begin(), values.end());
 738       }
 739 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 740         if (index < 0)
 741           throw std::out_of_range("index");
 742         if (count < 0)
 743           throw std::out_of_range("count");
 744         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 745           throw std::invalid_argument("invalid range");
 746         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 747       }
 748 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 749         if (index>=0 && index<(int)self->size()+1)
 750           self->insert(self->begin()+index, x);
 751         else
 752           throw std::out_of_range("index");
 753       }
 754 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 755         if (index>=0 && index<(int)self->size()+1)
 756           self->insert(self->begin()+index, values.begin(), values.end());
 757         else
 758           throw std::out_of_range("index");
 759       }
 760 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 761         if (index>=0 && index<(int)self->size())
 762           self->erase(self->begin() + index);
 763         else
 764           throw std::out_of_range("index");
 765       }
 766 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 767         if (index < 0)
 768           throw std::out_of_range("index");
 769         if (count < 0)
 770           throw std::out_of_range("count");
 771         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 772           throw std::invalid_argument("invalid range");
 773         self->erase(self->begin()+index, self->begin()+index+count);
 774       }
 775 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 776         if (count < 0)
 777           throw std::out_of_range("count");
 778         return new std::vector< Dali::TouchPoint >(count, value);
 779       }
 780 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 781         std::reverse(self->begin(), self->end());
 782       }
 783 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 784         if (index < 0)
 785           throw std::out_of_range("index");
 786         if (count < 0)
 787           throw std::out_of_range("count");
 788         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 789           throw std::invalid_argument("invalid range");
 790         std::reverse(self->begin()+index, self->begin()+index+count);
 791       }
 792 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 793         if (index < 0)
 794           throw std::out_of_range("index");
 795         if (index+values.size() > self->size())
 796           throw std::out_of_range("index");
 797         std::copy(values.begin(), values.end(), self->begin()+index);
 798       }
 799 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 800          return self->Empty();
 801       }
 802 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 803         return self->GetConnectionCount();
 804       }
 805 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 806           self->Connect( func );
 807       }
 808 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 809           self->Disconnect( func );
 810       }
 811 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 812           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 813 /*@SWIG@*/ self->Emit( arg );
 814       }
 815 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 816          return self->Empty();
 817       }
 818 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 819         return self->GetConnectionCount();
 820       }
 821 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 822           self->Connect( func );
 823       }
 824 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 825           self->Disconnect( func );
 826       }
 827 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 828           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 829 /*@SWIG@*/ self->Emit( arg );
 830       }
 831 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 832          return self->Empty();
 833       }
 834 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){
 835         return self->GetConnectionCount();
 836       }
 837 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 *)){
 838           self->Connect( func );
 839       }
 840 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 *)){
 841           self->Disconnect( func );
 842       }
 843 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){
 844           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 845 /*@SWIG@*/ self->Emit( arg );
 846       }
 847 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 848          return self->Empty();
 849       }
 850 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 851         return self->GetConnectionCount();
 852       }
 853 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 854           self->Connect( func );
 855       }
 856 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 857           self->Disconnect( func );
 858       }
 859 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 860           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 861 /*@SWIG@*/ self->Emit( arg );
 862       }
 863 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 864          return self->Empty();
 865       }
 866 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 867         return self->GetConnectionCount();
 868       }
 869 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 870           self->Connect( func );
 871       }
 872 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 873           self->Disconnect( func );
 874       }
 875 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 876           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 877 /*@SWIG@*/ self->Emit( arg );
 878       }
 879 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){
 880          return self->Empty();
 881       }
 882 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){
 883         return self->GetConnectionCount();
 884       }
 885 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 &)){
 886         self->Connect( func );
 887       }
 888 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 &)){
 889         self->Disconnect( func );
 890       }
 891 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){
 892         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 893 /*@SWIG@*/ self->Emit( arg1, arg2 );
 894       }
 895 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){
 896          return self->Empty();
 897       }
 898 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){
 899         return self->GetConnectionCount();
 900       }
 901 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 &)){
 902         self->Connect( func );
 903       }
 904 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 &)){
 905         self->Disconnect( func );
 906       }
 907 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){
 908         return self->Emit( arg1, arg2 );
 909       }
 910 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){
 911          return self->Empty();
 912       }
 913 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){
 914         return self->GetConnectionCount();
 915       }
 916 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 &)){
 917         self->Connect( func );
 918       }
 919 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 &)){
 920         self->Disconnect( func );
 921       }
 922 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){
 923         return self->Emit( arg1, arg2 );
 924       }
 925 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){
 926          return self->Empty();
 927       }
 928 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){
 929         return self->GetConnectionCount();
 930       }
 931 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 &)){
 932         self->Connect( func );
 933       }
 934 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 &)){
 935         self->Disconnect( func );
 936       }
 937 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){
 938         return self->Emit( arg1, arg2 );
 939       }
 940 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 941          return self->Empty();
 942       }
 943 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 944         return self->GetConnectionCount();
 945       }
 946 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 947           self->Connect( func );
 948       }
 949 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 950           self->Disconnect( func );
 951       }
 952 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 953           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 954 /*@SWIG@*/ self->Emit( arg );
 955       }
 956 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 957          return self->Empty();
 958       }
 959 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){
 960         return self->GetConnectionCount();
 961       }
 962 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 &)){
 963           self->Connect( func );
 964       }
 965 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 &)){
 966           self->Disconnect( func );
 967       }
 968 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){
 969           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 970 /*@SWIG@*/ self->Emit( arg );
 971       }
 972 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 973          return self->Empty();
 974       }
 975 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){
 976         return self->GetConnectionCount();
 977       }
 978 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 &)){
 979           self->Connect( func );
 980       }
 981 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 &)){
 982           self->Disconnect( func );
 983       }
 984 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){
 985           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 986 /*@SWIG@*/ self->Emit( arg );
 987       }
 988 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 989          return self->Empty();
 990       }
 991 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){
 992         return self->GetConnectionCount();
 993       }
 994 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 &)){
 995           self->Connect( func );
 996       }
 997 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 &)){
 998           self->Disconnect( func );
 999       }
1000 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){
1001           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1002 /*@SWIG@*/ self->Emit( arg );
1003       }
1004 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){
1005          return self->Empty();
1006       }
1007 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){
1008         return self->GetConnectionCount();
1009       }
1010 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 &)){
1011         self->Connect( func );
1012       }
1013 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 &)){
1014         self->Disconnect( func );
1015       }
1016 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){
1017         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1018 /*@SWIG@*/ self->Emit( arg1, arg2 );
1019       }
1020 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){
1021          return self->Empty();
1022       }
1023 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){
1024         return self->GetConnectionCount();
1025       }
1026 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 &)){
1027         self->Connect( func );
1028       }
1029 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 &)){
1030         self->Disconnect( func );
1031       }
1032 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){
1033         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1034 /*@SWIG@*/ self->Emit( arg1, arg2 );
1035       }
1036 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){
1037          return self->Empty();
1038       }
1039 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){
1040         return self->GetConnectionCount();
1041       }
1042 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 &)){
1043         self->Connect( func );
1044       }
1045 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 &)){
1046         self->Disconnect( func );
1047       }
1048 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){
1049         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1050 /*@SWIG@*/ self->Emit( arg1, arg2 );
1051       }
1052 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1053          return self->Empty();
1054       }
1055 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1056         return self->GetConnectionCount();
1057       }
1058 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1059           self->Connect( func );
1060       }
1061 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1062           self->Disconnect( func );
1063       }
1064 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1065           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1066 /*@SWIG@*/ self->Emit( arg );
1067       }
1068 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){
1069          return self->Empty();
1070       }
1071 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){
1072         return self->GetConnectionCount();
1073       }
1074 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)){
1075           return self->Connect( func );
1076       }
1077 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)){
1078           self->Disconnect( func );
1079       }
1080 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){
1081           self->Emit( arg1, arg3 );
1082       }
1083 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){
1084          return self->Empty();
1085       }
1086 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){
1087         return self->GetConnectionCount();
1088       }
1089 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)){
1090           return self->Connect( func );
1091       }
1092 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)){
1093           self->Disconnect( func );
1094       }
1095 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){
1096           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1097 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1098       }
1099
1100 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1101          return self->Empty();
1102       }
1103 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1104         return self->GetConnectionCount();
1105       }
1106 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1107           self->Connect( func );
1108       }
1109 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1110           self->Disconnect( func );
1111       }
1112 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1113           return self->Emit();
1114       }
1115
1116 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1117         std::vector< unsigned int >* pv = 0;
1118         if (capacity >= 0) {
1119           pv = new std::vector< unsigned int >();
1120           pv->reserve(capacity);
1121        } else {
1122           throw std::out_of_range("capacity");
1123        }
1124        return pv;
1125       }
1126 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1127         if (index>=0 && index<(int)self->size())
1128           return (*self)[index];
1129         else
1130           throw std::out_of_range("index");
1131       }
1132 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1133         if (index>=0 && index<(int)self->size())
1134           return (*self)[index];
1135         else
1136           throw std::out_of_range("index");
1137       }
1138 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1139         if (index>=0 && index<(int)self->size())
1140           (*self)[index] = val;
1141         else
1142           throw std::out_of_range("index");
1143       }
1144 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1145         self->insert(self->end(), values.begin(), values.end());
1146       }
1147 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1148         if (index < 0)
1149           throw std::out_of_range("index");
1150         if (count < 0)
1151           throw std::out_of_range("count");
1152         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1153           throw std::invalid_argument("invalid range");
1154         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1155       }
1156 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1157         if (index>=0 && index<(int)self->size()+1)
1158           self->insert(self->begin()+index, x);
1159         else
1160           throw std::out_of_range("index");
1161       }
1162 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1163         if (index>=0 && index<(int)self->size()+1)
1164           self->insert(self->begin()+index, values.begin(), values.end());
1165         else
1166           throw std::out_of_range("index");
1167       }
1168 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1169         if (index>=0 && index<(int)self->size())
1170           self->erase(self->begin() + index);
1171         else
1172           throw std::out_of_range("index");
1173       }
1174 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1175         if (index < 0)
1176           throw std::out_of_range("index");
1177         if (count < 0)
1178           throw std::out_of_range("count");
1179         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1180           throw std::invalid_argument("invalid range");
1181         self->erase(self->begin()+index, self->begin()+index+count);
1182       }
1183 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1184         if (count < 0)
1185           throw std::out_of_range("count");
1186         return new std::vector< unsigned int >(count, value);
1187       }
1188 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1189         std::reverse(self->begin(), self->end());
1190       }
1191 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1192         if (index < 0)
1193           throw std::out_of_range("index");
1194         if (count < 0)
1195           throw std::out_of_range("count");
1196         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1197           throw std::invalid_argument("invalid range");
1198         std::reverse(self->begin()+index, self->begin()+index+count);
1199       }
1200 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1201         if (index < 0)
1202           throw std::out_of_range("index");
1203         if (index+values.size() > self->size())
1204           throw std::out_of_range("index");
1205         std::copy(values.begin(), values.end(), self->begin()+index);
1206       }
1207 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1208         return std::find(self->begin(), self->end(), value) != self->end();
1209       }
1210 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1211         int index = -1;
1212         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1213         if (it != self->end())
1214           index = (int)(it - self->begin());
1215         return index;
1216       }
1217 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1218         int index = -1;
1219         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1220         if (rit != self->rend())
1221           index = (int)(self->rend() - 1 - rit);
1222         return index;
1223       }
1224 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1225         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1226         if (it != self->end()) {
1227           self->erase(it);
1228           return true;
1229         }
1230         return false;
1231       }
1232 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){
1233         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1234         if (capacity >= 0) {
1235           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1236           pv->reserve(capacity);
1237        } else {
1238           throw std::out_of_range("capacity");
1239        }
1240        return pv;
1241       }
1242 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){
1243         if (index>=0 && index<(int)self->size())
1244           return (*self)[index];
1245         else
1246           throw std::out_of_range("index");
1247       }
1248 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){
1249         if (index>=0 && index<(int)self->size())
1250           return (*self)[index];
1251         else
1252           throw std::out_of_range("index");
1253       }
1254 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){
1255         if (index>=0 && index<(int)self->size())
1256           (*self)[index] = val;
1257         else
1258           throw std::out_of_range("index");
1259       }
1260 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){
1261         self->insert(self->end(), values.begin(), values.end());
1262       }
1263 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){
1264         if (index < 0)
1265           throw std::out_of_range("index");
1266         if (count < 0)
1267           throw std::out_of_range("count");
1268         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1269           throw std::invalid_argument("invalid range");
1270         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1271       }
1272 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){
1273         if (index>=0 && index<(int)self->size()+1)
1274           self->insert(self->begin()+index, x);
1275         else
1276           throw std::out_of_range("index");
1277       }
1278 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){
1279         if (index>=0 && index<(int)self->size()+1)
1280           self->insert(self->begin()+index, values.begin(), values.end());
1281         else
1282           throw std::out_of_range("index");
1283       }
1284 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){
1285         if (index>=0 && index<(int)self->size())
1286           self->erase(self->begin() + index);
1287         else
1288           throw std::out_of_range("index");
1289       }
1290 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){
1291         if (index < 0)
1292           throw std::out_of_range("index");
1293         if (count < 0)
1294           throw std::out_of_range("count");
1295         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1296           throw std::invalid_argument("invalid range");
1297         self->erase(self->begin()+index, self->begin()+index+count);
1298       }
1299 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){
1300         if (count < 0)
1301           throw std::out_of_range("count");
1302         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1303       }
1304 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){
1305         std::reverse(self->begin(), self->end());
1306       }
1307 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){
1308         if (index < 0)
1309           throw std::out_of_range("index");
1310         if (count < 0)
1311           throw std::out_of_range("count");
1312         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1313           throw std::invalid_argument("invalid range");
1314         std::reverse(self->begin()+index, self->begin()+index+count);
1315       }
1316 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){
1317         if (index < 0)
1318           throw std::out_of_range("index");
1319         if (index+values.size() > self->size())
1320           throw std::out_of_range("index");
1321         std::copy(values.begin(), values.end(), self->begin()+index);
1322       }
1323 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1324         std::vector< Dali::Actor >* pv = 0;
1325         if (capacity >= 0) {
1326           pv = new std::vector< Dali::Actor >();
1327           pv->reserve(capacity);
1328        } else {
1329           throw std::out_of_range("capacity");
1330        }
1331        return pv;
1332       }
1333 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1334         if (index>=0 && index<(int)self->size())
1335           return (*self)[index];
1336         else
1337           throw std::out_of_range("index");
1338       }
1339 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1340         if (index>=0 && index<(int)self->size())
1341           return (*self)[index];
1342         else
1343           throw std::out_of_range("index");
1344       }
1345 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1346         if (index>=0 && index<(int)self->size())
1347           (*self)[index] = val;
1348         else
1349           throw std::out_of_range("index");
1350       }
1351 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1352         self->insert(self->end(), values.begin(), values.end());
1353       }
1354 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1355         if (index < 0)
1356           throw std::out_of_range("index");
1357         if (count < 0)
1358           throw std::out_of_range("count");
1359         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1360           throw std::invalid_argument("invalid range");
1361         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1362       }
1363 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1364         if (index>=0 && index<(int)self->size()+1)
1365           self->insert(self->begin()+index, x);
1366         else
1367           throw std::out_of_range("index");
1368       }
1369 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1370         if (index>=0 && index<(int)self->size()+1)
1371           self->insert(self->begin()+index, values.begin(), values.end());
1372         else
1373           throw std::out_of_range("index");
1374       }
1375 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1376         if (index>=0 && index<(int)self->size())
1377           self->erase(self->begin() + index);
1378         else
1379           throw std::out_of_range("index");
1380       }
1381 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1382         if (index < 0)
1383           throw std::out_of_range("index");
1384         if (count < 0)
1385           throw std::out_of_range("count");
1386         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1387           throw std::invalid_argument("invalid range");
1388         self->erase(self->begin()+index, self->begin()+index+count);
1389       }
1390 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1391         if (count < 0)
1392           throw std::out_of_range("count");
1393         return new std::vector< Dali::Actor >(count, value);
1394       }
1395 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1396         std::reverse(self->begin(), self->end());
1397       }
1398 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1399         if (index < 0)
1400           throw std::out_of_range("index");
1401         if (count < 0)
1402           throw std::out_of_range("count");
1403         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1404           throw std::invalid_argument("invalid range");
1405         std::reverse(self->begin()+index, self->begin()+index+count);
1406       }
1407 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1408         if (index < 0)
1409           throw std::out_of_range("index");
1410         if (index+values.size() > self->size())
1411           throw std::out_of_range("index");
1412         std::copy(values.begin(), values.end(), self->begin()+index);
1413       }
1414 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1415          return self->Empty();
1416       }
1417 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1418         return self->GetConnectionCount();
1419       }
1420 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 &)){
1421           self->Connect( func );
1422       }
1423 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 &)){
1424           self->Disconnect( func );
1425       }
1426 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){
1427           return self->Emit( arg );
1428       }
1429 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){
1430          return self->Empty();
1431       }
1432 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){
1433         return self->GetConnectionCount();
1434       }
1435 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)){
1436         self->Connect( func );
1437       }
1438 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)){
1439         self->Disconnect( func );
1440       }
1441 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){
1442         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1443 /*@SWIG@*/ self->Emit( arg1, arg2 );
1444       }
1445 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1446          return self->Empty();
1447       }
1448 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){
1449         return self->GetConnectionCount();
1450       }
1451 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)){
1452         self->Connect( func );
1453       }
1454 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)){
1455         self->Disconnect( func );
1456       }
1457 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){
1458         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1459 /*@SWIG@*/ self->Emit( arg1, arg2 );
1460       }
1461 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1462          return self->Empty();
1463       }
1464 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1465         return self->GetConnectionCount();
1466       }
1467 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)){
1468         self->Connect( func );
1469       }
1470 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)){
1471         self->Disconnect( func );
1472       }
1473 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){
1474         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1475 /*@SWIG@*/ self->Emit( arg1, arg2 );
1476       }
1477 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){
1478          return self->Empty();
1479       }
1480 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){
1481         return self->GetConnectionCount();
1482       }
1483 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)){
1484         self->Connect( func );
1485       }
1486 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)){
1487         self->Disconnect( func );
1488       }
1489 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){
1490         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1491 /*@SWIG@*/ self->Emit( arg1, arg2 );
1492       }
1493 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1494          return self->Empty();
1495       }
1496 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1497         return self->GetConnectionCount();
1498       }
1499 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)){
1500           self->Connect( func );
1501       }
1502 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)){
1503           self->Disconnect( func );
1504       }
1505 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1506           return self->Emit( arg );
1507       }
1508 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1509          return self->Empty();
1510       }
1511 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1512         return self->GetConnectionCount();
1513       }
1514 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)){
1515           self->Connect( func );
1516       }
1517 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)){
1518           self->Disconnect( func );
1519       }
1520 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1521           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1522 /*@SWIG@*/ self->Emit( arg );
1523       }
1524 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){
1525          return self->Empty();
1526       }
1527 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){
1528         return self->GetConnectionCount();
1529       }
1530 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)){
1531           return self->Connect( func );
1532       }
1533 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)){
1534           self->Disconnect( func );
1535       }
1536 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){
1537           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1538 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1539       }
1540 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1541          return self->Empty();
1542       }
1543 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1544         return self->GetConnectionCount();
1545       }
1546 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)){
1547           self->Connect( func );
1548       }
1549 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)){
1550           self->Disconnect( func );
1551       }
1552 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1553           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1554 /*@SWIG@*/ self->Emit( arg );
1555       }
1556 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){
1557          return self->Empty();
1558       }
1559 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){
1560         return self->GetConnectionCount();
1561       }
1562 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)){
1563           return self->Connect( func );
1564       }
1565 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)){
1566           self->Disconnect( func );
1567       }
1568 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){
1569           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1570 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1571       }
1572 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){
1573          return self->Empty();
1574       }
1575 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){
1576         return self->GetConnectionCount();
1577       }
1578 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 &)){
1579           self->Connect( func );
1580       }
1581 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 &)){
1582           self->Disconnect( func );
1583       }
1584 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){
1585           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1586 /*@SWIG@*/ self->Emit( arg );
1587       }
1588 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1589          return self->Empty();
1590       }
1591 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){
1592         return self->GetConnectionCount();
1593       }
1594 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 &)){
1595           self->Connect( func );
1596       }
1597 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 &)){
1598           self->Disconnect( func );
1599       }
1600 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){
1601           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1602 /*@SWIG@*/ self->Emit( arg );
1603       }
1604
1605
1606 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){
1607          return self->Empty();
1608       }
1609 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){
1610         return self->GetConnectionCount();
1611       }
1612 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 &)){
1613         self->Connect( func );
1614       }
1615 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 &)){
1616         self->Disconnect( func );
1617       }
1618 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){
1619         return self->Emit( arg1, arg2 );
1620       }
1621 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1622          return self->Empty();
1623       }
1624 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1625         return self->GetConnectionCount();
1626       }
1627 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)){
1628           self->Connect( func );
1629       }
1630 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)){
1631           self->Disconnect( func );
1632       }
1633 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1634           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1635 /*@SWIG@*/ self->Emit( arg );
1636       }
1637 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1638          return self->Empty();
1639       }
1640 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1641         return self->GetConnectionCount();
1642       }
1643 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 &)){
1644           self->Connect( func );
1645       }
1646 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 &)){
1647           self->Disconnect( func );
1648       }
1649 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){
1650           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1651 /*@SWIG@*/ self->Emit( arg );
1652       }
1653 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1654          return self->Empty();
1655       }
1656 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){
1657         return self->GetConnectionCount();
1658       }
1659 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)){
1660         self->Connect( func );
1661       }
1662 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)){
1663         self->Disconnect( func );
1664       }
1665 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){
1666         return self->Emit( arg1, arg2 );
1667       }
1668 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1669          return self->Empty();
1670       }
1671 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){
1672         return self->GetConnectionCount();
1673       }
1674 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)){
1675         self->Connect( func );
1676       }
1677 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)){
1678         self->Disconnect( func );
1679       }
1680 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){
1681         return self->Emit( arg1, arg2 );
1682       }
1683
1684
1685 /* ---------------------------------------------------
1686  * C++ director class methods
1687  * --------------------------------------------------- */
1688
1689 #include "dali_wrap.h"
1690
1691 /*
1692  *  Widget director
1693  */
1694 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1695   swig_init_callbacks();
1696 }
1697
1698 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1699 }
1700
1701 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1702   char * jcontentInfo = 0 ;
1703   void * jwindow  ;
1704
1705   if (!swig_callbackOnCreate) {
1706     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1707     return;
1708   } else {
1709     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1710     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1711     swig_callbackOnCreate(jcontentInfo, jwindow);
1712   }
1713 }
1714
1715 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1716   char * jcontentInfo = 0 ;
1717   int jtype  ;
1718
1719   if (!swig_callbackOnTerminate) {
1720     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1721     return;
1722   } else {
1723     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1724     jtype = (int)type;
1725     swig_callbackOnTerminate(jcontentInfo, jtype);
1726   }
1727 }
1728
1729 void SwigDirector_WidgetImpl::OnPause() {
1730   if (!swig_callbackOnPause) {
1731     Dali::Internal::Adaptor::Widget::OnPause();
1732     return;
1733   } else {
1734     swig_callbackOnPause();
1735   }
1736 }
1737
1738 void SwigDirector_WidgetImpl::OnResume() {
1739   if (!swig_callbackOnResume) {
1740     Dali::Internal::Adaptor::Widget::OnResume();
1741     return;
1742   } else {
1743     swig_callbackOnResume();
1744   }
1745 }
1746
1747 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1748   void * jwindow  ;
1749
1750   if (!swig_callbackOnResize) {
1751     Dali::Internal::Adaptor::Widget::OnResize(window);
1752     return;
1753   } else {
1754     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1755     swig_callbackOnResize(jwindow);
1756   }
1757 }
1758
1759 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1760   char * jcontentInfo = 0 ;
1761   int jforce  ;
1762
1763   if (!swig_callbackOnUpdate) {
1764     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1765     return;
1766   } else {
1767     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1768     jforce = force;
1769     swig_callbackOnUpdate(jcontentInfo, jforce);
1770   }
1771 }
1772
1773 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1774   void * jslotObserver = 0 ;
1775   void * jcallback = 0 ;
1776
1777   if (!swig_callbackSignalConnected) {
1778     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1779     return;
1780   } else {
1781     jslotObserver = (void *) slotObserver;
1782     jcallback = (void *) callback;
1783     swig_callbackSignalConnected(jslotObserver, jcallback);
1784   }
1785 }
1786
1787 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1788   void * jslotObserver = 0 ;
1789   void * jcallback = 0 ;
1790
1791   if (!swig_callbackSignalDisconnected) {
1792     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1793     return;
1794   } else {
1795     jslotObserver = (void *) slotObserver;
1796     jcallback = (void *) callback;
1797     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1798   }
1799 }
1800
1801 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) {
1802
1803   swig_callbackOnCreate = callbackOnCreate;
1804   swig_callbackOnTerminate = callbackOnTerminate;
1805   swig_callbackOnPause = callbackOnPause;
1806   swig_callbackOnResume = callbackOnResume;
1807   swig_callbackOnResize = callbackOnResize;
1808   swig_callbackOnUpdate = callbackOnUpdate;
1809   swig_callbackSignalConnected = callbackSignalConnected;
1810   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1811 }
1812
1813 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1814   swig_callbackOnCreate = 0;
1815   swig_callbackOnTerminate = 0;
1816   swig_callbackOnPause = 0;
1817   swig_callbackOnResume = 0;
1818   swig_callbackOnResize = 0;
1819   swig_callbackOnUpdate = 0;
1820   swig_callbackSignalConnected = 0;
1821   swig_callbackSignalDisconnected = 0;
1822 }
1823
1824
1825 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1826   swig_init_callbacks();
1827 }
1828
1829 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1830
1831 }
1832
1833
1834 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1835   int jdepth  ;
1836
1837   if (!swig_callbackOnStageConnection) {
1838     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1839     return;
1840   } else {
1841     jdepth = depth;
1842     swig_callbackOnStageConnection(jdepth);
1843   }
1844 }
1845
1846 void SwigDirector_ViewImpl::OnStageDisconnection() {
1847   if (!swig_callbackOnStageDisconnection) {
1848     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1849     return;
1850   } else {
1851     swig_callbackOnStageDisconnection();
1852   }
1853 }
1854
1855 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1856   void * jchild = 0 ;
1857
1858   if (!swig_callbackOnChildAdd) {
1859     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1860     return;
1861   } else {
1862     jchild = (Dali::Actor *) &child;
1863     swig_callbackOnChildAdd(jchild);
1864   }
1865 }
1866
1867 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1868   void * jchild = 0 ;
1869
1870   if (!swig_callbackOnChildRemove) {
1871     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1872     return;
1873   } else {
1874     jchild = (Dali::Actor *) &child;
1875     swig_callbackOnChildRemove(jchild);
1876   }
1877 }
1878
1879 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1880   int jindex  ;
1881   void * jpropertyValue  ;
1882
1883   if (!swig_callbackOnPropertySet) {
1884     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1885     return;
1886   } else {
1887     jindex = index;
1888     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1889     swig_callbackOnPropertySet(jindex, jpropertyValue);
1890   }
1891 }
1892
1893 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1894   void * jtargetSize = 0 ;
1895
1896   if (!swig_callbackOnSizeSet) {
1897     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1898     return;
1899   } else {
1900     jtargetSize = (Dali::Vector3 *) &targetSize;
1901     swig_callbackOnSizeSet(jtargetSize);
1902   }
1903 }
1904
1905 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1906   void * janimation = 0 ;
1907   void * jtargetSize = 0 ;
1908
1909   if (!swig_callbackOnSizeAnimation) {
1910     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1911     return;
1912   } else {
1913     janimation = (Dali::Animation *) &animation;
1914     jtargetSize = (Dali::Vector3 *) &targetSize;
1915     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1916   }
1917 }
1918
1919 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1920   bool c_result = SwigValueInit< bool >() ;
1921   unsigned int jresult = 0 ;
1922   void * jarg0 = 0 ;
1923
1924   if (!swig_callbackOnTouchEvent) {
1925     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1926   } else {
1927     jarg0 = (Dali::TouchEvent *) &event;
1928     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1929     c_result = jresult ? true : false;
1930   }
1931   return c_result;
1932 }
1933
1934 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1935   bool c_result = SwigValueInit< bool >() ;
1936   unsigned int jresult = 0 ;
1937   void * jarg0 = 0 ;
1938
1939   if (!swig_callbackOnHoverEvent) {
1940     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1941   } else {
1942     jarg0 = (Dali::HoverEvent *) &event;
1943     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1944     c_result = jresult ? true : false;
1945   }
1946   return c_result;
1947 }
1948
1949 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1950   bool c_result = SwigValueInit< bool >() ;
1951   unsigned int jresult = 0 ;
1952   void * jarg0 = 0 ;
1953
1954   if (!swig_callbackOnKeyEvent) {
1955     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1956   } else {
1957     jarg0 = (Dali::KeyEvent *) &event;
1958     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1959     c_result = jresult ? true : false;
1960   }
1961   return c_result;
1962 }
1963
1964 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1965   bool c_result = SwigValueInit< bool >() ;
1966   unsigned int jresult = 0 ;
1967   void * jarg0 = 0 ;
1968
1969   if (!swig_callbackOnWheelEvent) {
1970     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1971   } else {
1972     jarg0 = (Dali::WheelEvent *) &event;
1973     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1974     c_result = jresult ? true : false;
1975   }
1976   return c_result;
1977 }
1978
1979 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1980   void * jsize = 0 ;
1981   void * jcontainer = 0 ;
1982
1983   if (!swig_callbackOnRelayout) {
1984     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1985     return;
1986   } else {
1987     jsize = (Dali::Vector2 *) &size;
1988     jcontainer = (Dali::RelayoutContainer *) &container;
1989     swig_callbackOnRelayout(jsize, jcontainer);
1990   }
1991 }
1992
1993 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1994   int jpolicy  ;
1995   int jdimension  ;
1996
1997   if (!swig_callbackOnSetResizePolicy) {
1998     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1999     return;
2000   } else {
2001     jpolicy = (int)policy;
2002     jdimension = (int)dimension;
2003     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2004   }
2005 }
2006
2007 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2008   Dali::Vector3 c_result ;
2009   void * jresult = 0 ;
2010
2011   if (!swig_callbackGetNaturalSize) {
2012     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2013   } else {
2014     jresult = (void *) swig_callbackGetNaturalSize();
2015     if (!jresult) {
2016       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2017       return c_result;
2018     }
2019     c_result = *(Dali::Vector3 *)jresult;
2020   }
2021   return c_result;
2022 }
2023
2024 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2025   float c_result = SwigValueInit< float >() ;
2026   float jresult = 0 ;
2027   void * jchild = 0 ;
2028   int jdimension  ;
2029
2030   if (!swig_callbackCalculateChildSize) {
2031     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2032   } else {
2033     jchild = (Dali::Actor *) &child;
2034     jdimension = (int)dimension;
2035     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2036     c_result = (float)jresult;
2037   }
2038   return c_result;
2039 }
2040
2041 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2042   float c_result = SwigValueInit< float >() ;
2043   float jresult = 0 ;
2044   float jwidth  ;
2045
2046   if (!swig_callbackGetHeightForWidth) {
2047     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2048   } else {
2049     jwidth = width;
2050     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2051     c_result = (float)jresult;
2052   }
2053   return c_result;
2054 }
2055
2056 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2057   float c_result = SwigValueInit< float >() ;
2058   float jresult = 0 ;
2059   float jheight  ;
2060
2061   if (!swig_callbackGetWidthForHeight) {
2062     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2063   } else {
2064     jheight = height;
2065     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2066     c_result = (float)jresult;
2067   }
2068   return c_result;
2069 }
2070
2071 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2072   bool c_result = SwigValueInit< bool >() ;
2073   unsigned int jresult = 0 ;
2074   int jdimension  ;
2075
2076   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2077     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2078   } else {
2079     jdimension = (int)dimension;
2080     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2081     c_result = jresult ? true : false;
2082   }
2083   return c_result;
2084 }
2085
2086 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2087   int jdimension  ;
2088
2089   if (!swig_callbackOnCalculateRelayoutSize) {
2090     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2091     return;
2092   } else {
2093     jdimension = (int)dimension;
2094     swig_callbackOnCalculateRelayoutSize(jdimension);
2095   }
2096 }
2097
2098 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2099   float jsize  ;
2100   int jdimension  ;
2101
2102   if (!swig_callbackOnLayoutNegotiated) {
2103     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2104     return;
2105   } else {
2106     jsize = size;
2107     jdimension = (int)dimension;
2108     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2109   }
2110 }
2111
2112 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2113   return Dali::CustomActorImpl::GetExtension();
2114 }
2115
2116 void SwigDirector_ViewImpl::OnInitialize() {
2117   if (!swig_callbackOnInitialize) {
2118     Dali::Toolkit::Internal::Control::OnInitialize();
2119     return;
2120   } else {
2121     swig_callbackOnInitialize();
2122   }
2123 }
2124
2125 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2126   void * jchild = 0 ;
2127
2128   if (!swig_callbackOnControlChildAdd) {
2129     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2130     return;
2131   } else {
2132     jchild = (Dali::Actor *) &child;
2133     swig_callbackOnControlChildAdd(jchild);
2134   }
2135 }
2136
2137 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2138   void * jchild = 0 ;
2139
2140   if (!swig_callbackOnControlChildRemove) {
2141     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2142     return;
2143   } else {
2144     jchild = (Dali::Actor *) &child;
2145     swig_callbackOnControlChildRemove(jchild);
2146   }
2147 }
2148
2149 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2150   void * jstyleManager  ;
2151   int jchange  ;
2152
2153   if (!swig_callbackOnStyleChange) {
2154     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2155     return;
2156   } else {
2157     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2158     jchange = (int)change;
2159     swig_callbackOnStyleChange(jstyleManager, jchange);
2160   }
2161 }
2162
2163 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2164   bool c_result = SwigValueInit< bool >() ;
2165   unsigned int jresult = 0 ;
2166
2167   if (!swig_callbackOnAccessibilityActivated) {
2168     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2169   } else {
2170     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2171     c_result = jresult ? true : false;
2172   }
2173   return c_result;
2174 }
2175
2176 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2177   bool c_result = SwigValueInit< bool >() ;
2178   unsigned int jresult = 0 ;
2179   void * jgesture  ;
2180
2181   if (!swig_callbackOnAccessibilityPan) {
2182     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2183   } else {
2184     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2185     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2186     c_result = jresult ? true : false;
2187   }
2188   return c_result;
2189 }
2190
2191 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2192   bool c_result = SwigValueInit< bool >() ;
2193   unsigned int jresult = 0 ;
2194   void * jtouchEvent = 0 ;
2195
2196   if (!swig_callbackOnAccessibilityTouch) {
2197     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2198   } else {
2199     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2200     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2201     c_result = jresult ? true : false;
2202   }
2203   return c_result;
2204 }
2205
2206 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2207   bool c_result = SwigValueInit< bool >() ;
2208   unsigned int jresult = 0 ;
2209   unsigned int jisIncrease  ;
2210
2211   if (!swig_callbackOnAccessibilityValueChange) {
2212     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2213   } else {
2214     jisIncrease = isIncrease;
2215     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2216     c_result = jresult ? true : false;
2217   }
2218   return c_result;
2219 }
2220
2221 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2222   bool c_result = SwigValueInit< bool >() ;
2223   unsigned int jresult = 0 ;
2224
2225   if (!swig_callbackOnAccessibilityZoom) {
2226     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2227   } else {
2228     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2229     c_result = jresult ? true : false;
2230   }
2231   return c_result;
2232 }
2233
2234 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2235   if (!swig_callbackOnKeyInputFocusGained) {
2236     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2237     return;
2238   } else {
2239     swig_callbackOnKeyInputFocusGained();
2240   }
2241 }
2242
2243 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2244   if (!swig_callbackOnKeyInputFocusLost) {
2245     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2246     return;
2247   } else {
2248     swig_callbackOnKeyInputFocusLost();
2249   }
2250 }
2251
2252 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2253   Dali::Actor c_result ;
2254   void * jresult = 0 ;
2255   void * jcurrentFocusedActor  ;
2256   int jdirection  ;
2257   unsigned int jloopEnabled  ;
2258
2259   if (!swig_callbackGetNextKeyboardFocusableActor) {
2260     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2261   } else {
2262     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2263     jdirection = (int)direction;
2264     jloopEnabled = loopEnabled;
2265     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2266     if (!jresult) {
2267       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2268       return c_result;
2269     }
2270     c_result = *(Dali::Actor *)jresult;
2271   }
2272   return c_result;
2273 }
2274
2275 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2276   void * jcommitedFocusableActor  ;
2277
2278   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2279     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2280     return;
2281   } else {
2282     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2283     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2284   }
2285 }
2286
2287 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2288   bool c_result = SwigValueInit< bool >() ;
2289   unsigned int jresult = 0 ;
2290
2291   if (!swig_callbackOnKeyboardEnter) {
2292     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2293   } else {
2294     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2295     c_result = jresult ? true : false;
2296   }
2297   return c_result;
2298 }
2299
2300 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2301   void * jpinch = 0 ;
2302
2303   if (!swig_callbackOnPinch) {
2304     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2305     return;
2306   } else {
2307     jpinch = (Dali::PinchGesture *) &pinch;
2308     swig_callbackOnPinch(jpinch);
2309   }
2310 }
2311
2312 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2313   void * jpan = 0 ;
2314
2315   if (!swig_callbackOnPan) {
2316     Dali::Toolkit::Internal::Control::OnPan(pan);
2317     return;
2318   } else {
2319     jpan = (Dali::PanGesture *) &pan;
2320     swig_callbackOnPan(jpan);
2321   }
2322 }
2323
2324 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2325   void * jtap = 0 ;
2326
2327   if (!swig_callbackOnTap) {
2328     Dali::Toolkit::Internal::Control::OnTap(tap);
2329     return;
2330   } else {
2331     jtap = (Dali::TapGesture *) &tap;
2332     swig_callbackOnTap(jtap);
2333   }
2334 }
2335
2336 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2337   void * jlongPress = 0 ;
2338
2339   if (!swig_callbackOnLongPress) {
2340     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2341     return;
2342   } else {
2343     jlongPress = (Dali::LongPressGesture *) &longPress;
2344     swig_callbackOnLongPress(jlongPress);
2345   }
2346 }
2347
2348 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2349   void * jslotObserver = 0 ;
2350   void * jcallback = 0 ;
2351
2352   if (!swig_callbackSignalConnected) {
2353     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2354     return;
2355   } else {
2356     jslotObserver = (void *) slotObserver;
2357     jcallback = (void *) callback;
2358     swig_callbackSignalConnected(jslotObserver, jcallback);
2359   }
2360 }
2361
2362 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2363   void * jslotObserver = 0 ;
2364   void * jcallback = 0 ;
2365
2366   if (!swig_callbackSignalDisconnected) {
2367     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2368     return;
2369   } else {
2370     jslotObserver = (void *) slotObserver;
2371     jcallback = (void *) callback;
2372     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2373   }
2374 }
2375
2376 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2377   return Dali::Toolkit::Internal::Control::GetControlExtension();
2378 }
2379
2380 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) {
2381   swig_callbackOnStageConnection = callbackOnStageConnection;
2382   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2383   swig_callbackOnChildAdd = callbackOnChildAdd;
2384   swig_callbackOnChildRemove = callbackOnChildRemove;
2385   swig_callbackOnPropertySet = callbackOnPropertySet;
2386   swig_callbackOnSizeSet = callbackOnSizeSet;
2387   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2388   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2389   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2390   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2391   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2392   swig_callbackOnRelayout = callbackOnRelayout;
2393   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2394   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2395   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2396   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2397   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2398   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2399   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2400   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2401   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2402   swig_callbackOnInitialize = callbackOnInitialize;
2403   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2404   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2405   swig_callbackOnStyleChange = callbackOnStyleChange;
2406   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2407   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2408   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2409   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2410   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2411   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2412   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2413   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2414   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2415   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2416   swig_callbackOnPinch = callbackOnPinch;
2417   swig_callbackOnPan = callbackOnPan;
2418   swig_callbackOnTap = callbackOnTap;
2419   swig_callbackOnLongPress = callbackOnLongPress;
2420   swig_callbackSignalConnected = callbackSignalConnected;
2421   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2422 }
2423
2424 void SwigDirector_ViewImpl::swig_init_callbacks() {
2425   swig_callbackOnStageConnection = 0;
2426   swig_callbackOnStageDisconnection = 0;
2427   swig_callbackOnChildAdd = 0;
2428   swig_callbackOnChildRemove = 0;
2429   swig_callbackOnPropertySet = 0;
2430   swig_callbackOnSizeSet = 0;
2431   swig_callbackOnSizeAnimation = 0;
2432   swig_callbackOnTouchEvent = 0;
2433   swig_callbackOnHoverEvent = 0;
2434   swig_callbackOnKeyEvent = 0;
2435   swig_callbackOnWheelEvent = 0;
2436   swig_callbackOnRelayout = 0;
2437   swig_callbackOnSetResizePolicy = 0;
2438   swig_callbackGetNaturalSize = 0;
2439   swig_callbackCalculateChildSize = 0;
2440   swig_callbackGetHeightForWidth = 0;
2441   swig_callbackGetWidthForHeight = 0;
2442   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2443   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2444   swig_callbackOnCalculateRelayoutSize = 0;
2445   swig_callbackOnLayoutNegotiated = 0;
2446   swig_callbackOnInitialize = 0;
2447   swig_callbackOnControlChildAdd = 0;
2448   swig_callbackOnControlChildRemove = 0;
2449   swig_callbackOnStyleChange = 0;
2450   swig_callbackOnAccessibilityActivated = 0;
2451   swig_callbackOnAccessibilityPan = 0;
2452   swig_callbackOnAccessibilityTouch = 0;
2453   swig_callbackOnAccessibilityValueChange = 0;
2454   swig_callbackOnAccessibilityZoom = 0;
2455   swig_callbackOnKeyInputFocusGained = 0;
2456   swig_callbackOnKeyInputFocusLost = 0;
2457   swig_callbackGetNextKeyboardFocusableActor = 0;
2458   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2459   swig_callbackOnKeyboardEnter = 0;
2460   swig_callbackOnPinch = 0;
2461   swig_callbackOnPan = 0;
2462   swig_callbackOnTap = 0;
2463   swig_callbackOnLongPress = 0;
2464   swig_callbackSignalConnected = 0;
2465   swig_callbackSignalDisconnected = 0;
2466 }
2467
2468 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2469   swig_init_callbacks();
2470 }
2471
2472 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2473
2474 }
2475
2476
2477 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2478   unsigned int c_result = SwigValueInit< unsigned int >() ;
2479   unsigned int jresult = 0 ;
2480
2481   if (!swig_callbackGetNumberOfItems) {
2482     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2483   } else {
2484     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2485     c_result = (unsigned int)jresult;
2486   }
2487   return c_result;
2488 }
2489
2490 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2491   Dali::Actor c_result ;
2492   void * jresult = 0 ;
2493   unsigned int jitemId  ;
2494
2495   if (!swig_callbackNewItem) {
2496     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2497   } else {
2498     jitemId = itemId;
2499     jresult = (void *) swig_callbackNewItem(jitemId);
2500     if (!jresult) {
2501       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2502       return c_result;
2503     }
2504     c_result = *(Dali::Actor *)jresult;
2505   }
2506   return c_result;
2507 }
2508
2509 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2510   unsigned int jitemId  ;
2511   void * jactor  ;
2512
2513   if (!swig_callbackItemReleased) {
2514     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2515     return;
2516   } else {
2517     jitemId = itemId;
2518     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2519     swig_callbackItemReleased(jitemId, jactor);
2520   }
2521 }
2522
2523 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2524   return Dali::Toolkit::ItemFactory::GetExtension();
2525 }
2526
2527 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2528   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2529   swig_callbackNewItem = callbackNewItem;
2530   swig_callbackItemReleased = callbackItemReleased;
2531 }
2532
2533 void SwigDirector_ItemFactory::swig_init_callbacks() {
2534   swig_callbackGetNumberOfItems = 0;
2535   swig_callbackNewItem = 0;
2536   swig_callbackItemReleased = 0;
2537 }
2538
2539 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2540   swig_init_callbacks();
2541 }
2542
2543 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2544
2545 }
2546
2547
2548 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2549   Dali::Actor c_result ;
2550   void * jresult = 0 ;
2551   void * jcurrent  ;
2552   void * jproposed  ;
2553   int jdirection  ;
2554
2555   if (!swig_callbackGetNextFocusableActor) {
2556     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2557   } else {
2558     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2559     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2560     jdirection = (int)direction;
2561     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2562     if (!jresult) {
2563       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2564       return c_result;
2565     }
2566     c_result = *(Dali::Actor *)jresult;
2567   }
2568   return c_result;
2569 }
2570
2571 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2572   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2573 }
2574
2575 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2576   swig_callbackGetNextFocusableActor = 0;
2577 }
2578
2579
2580 #ifdef __cplusplus
2581 extern "C" {
2582 #endif
2583
2584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2585   void * jresult ;
2586   floatp *result = 0 ;
2587
2588   {
2589     try {
2590       result = (floatp *)new_floatp();
2591     } catch (std::out_of_range& e) {
2592       {
2593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2594       };
2595     } catch (std::exception& e) {
2596       {
2597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2598       };
2599     } catch (DaliException e) {
2600       {
2601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2602       };
2603     } catch (...) {
2604       {
2605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2606       };
2607     }
2608   }
2609   jresult = (void *)result;
2610   return jresult;
2611 }
2612
2613
2614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2615   floatp *arg1 = (floatp *) 0 ;
2616
2617   arg1 = (floatp *)jarg1;
2618   {
2619     try {
2620       delete_floatp(arg1);
2621     } catch (std::out_of_range& e) {
2622       {
2623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2624       };
2625     } catch (std::exception& e) {
2626       {
2627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2628       };
2629     } catch (Dali::DaliException e) {
2630       {
2631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2632       };
2633     } catch (...) {
2634       {
2635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2636       };
2637     }
2638   }
2639
2640 }
2641
2642
2643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2644   floatp *arg1 = (floatp *) 0 ;
2645   float arg2 ;
2646
2647   arg1 = (floatp *)jarg1;
2648   arg2 = (float)jarg2;
2649   {
2650     try {
2651       floatp_assign(arg1,arg2);
2652     } catch (std::out_of_range& e) {
2653       {
2654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2655       };
2656     } catch (std::exception& e) {
2657       {
2658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2659       };
2660     } catch (Dali::DaliException e) {
2661       {
2662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2663       };
2664     } catch (...) {
2665       {
2666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2667       };
2668     }
2669   }
2670
2671 }
2672
2673
2674 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2675   float jresult ;
2676   floatp *arg1 = (floatp *) 0 ;
2677   float result;
2678
2679   arg1 = (floatp *)jarg1;
2680   {
2681     try {
2682       result = (float)floatp_value(arg1);
2683     } catch (std::out_of_range& e) {
2684       {
2685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2686       };
2687     } catch (std::exception& e) {
2688       {
2689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2690       };
2691     } catch (DaliException e) {
2692       {
2693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2694       };
2695     } catch (...) {
2696       {
2697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2698       };
2699     }
2700   }
2701   jresult = result;
2702   return jresult;
2703 }
2704
2705
2706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2707   void * jresult ;
2708   floatp *arg1 = (floatp *) 0 ;
2709   float *result = 0 ;
2710
2711   arg1 = (floatp *)jarg1;
2712   {
2713     try {
2714       result = (float *)floatp_cast(arg1);
2715     } catch (std::out_of_range& e) {
2716       {
2717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2718       };
2719     } catch (std::exception& e) {
2720       {
2721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2722       };
2723     } catch (Dali::DaliException e) {
2724       {
2725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2726       };
2727     } catch (...) {
2728       {
2729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2730       };
2731     }
2732   }
2733
2734   jresult = (void *)result;
2735   return jresult;
2736 }
2737
2738
2739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2740   void * jresult ;
2741   float *arg1 = (float *) 0 ;
2742   floatp *result = 0 ;
2743
2744   arg1 = (float *)jarg1;
2745   {
2746     try {
2747       result = (floatp *)floatp_frompointer(arg1);
2748     } catch (std::out_of_range& e) {
2749       {
2750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2751       };
2752     } catch (std::exception& e) {
2753       {
2754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2755       };
2756     } catch (Dali::DaliException e) {
2757       {
2758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2759       };
2760     } catch (...) {
2761       {
2762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2763       };
2764     }
2765   }
2766
2767   jresult = (void *)result;
2768   return jresult;
2769 }
2770
2771
2772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2773   void * jresult ;
2774   intp *result = 0 ;
2775
2776   {
2777     try {
2778       result = (intp *)new_intp();
2779     } catch (std::out_of_range& e) {
2780       {
2781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2782       };
2783     } catch (std::exception& e) {
2784       {
2785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2786       };
2787     } catch (Dali::DaliException e) {
2788       {
2789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2790       };
2791     } catch (...) {
2792       {
2793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2794       };
2795     }
2796   }
2797
2798   jresult = (void *)result;
2799   return jresult;
2800 }
2801
2802
2803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2804   intp *arg1 = (intp *) 0 ;
2805
2806   arg1 = (intp *)jarg1;
2807   {
2808     try {
2809       delete_intp(arg1);
2810     } catch (std::out_of_range& e) {
2811       {
2812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2813       };
2814     } catch (std::exception& e) {
2815       {
2816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2817       };
2818     } catch (Dali::DaliException e) {
2819       {
2820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2821       };
2822     } catch (...) {
2823       {
2824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2825       };
2826     }
2827   }
2828
2829 }
2830
2831
2832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2833   intp *arg1 = (intp *) 0 ;
2834   int arg2 ;
2835
2836   arg1 = (intp *)jarg1;
2837   arg2 = (int)jarg2;
2838   {
2839     try {
2840       intp_assign(arg1,arg2);
2841     } catch (std::out_of_range& e) {
2842       {
2843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2844       };
2845     } catch (std::exception& e) {
2846       {
2847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2848       };
2849     } catch (Dali::DaliException e) {
2850       {
2851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2852       };
2853     } catch (...) {
2854       {
2855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2856       };
2857     }
2858   }
2859
2860 }
2861
2862
2863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2864   int jresult ;
2865   intp *arg1 = (intp *) 0 ;
2866   int result;
2867
2868   arg1 = (intp *)jarg1;
2869   {
2870     try {
2871       result = (int)intp_value(arg1);
2872     } catch (std::out_of_range& e) {
2873       {
2874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2875       };
2876     } catch (std::exception& e) {
2877       {
2878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2879       };
2880     } catch (Dali::DaliException e) {
2881       {
2882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2883       };
2884     } catch (...) {
2885       {
2886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2887       };
2888     }
2889   }
2890
2891   jresult = result;
2892   return jresult;
2893 }
2894
2895
2896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2897   void * jresult ;
2898   intp *arg1 = (intp *) 0 ;
2899   int *result = 0 ;
2900
2901   arg1 = (intp *)jarg1;
2902   {
2903     try {
2904       result = (int *)intp_cast(arg1);
2905     } catch (std::out_of_range& e) {
2906       {
2907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2908       };
2909     } catch (std::exception& e) {
2910       {
2911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2912       };
2913     } catch (Dali::DaliException e) {
2914       {
2915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2916       };
2917     } catch (...) {
2918       {
2919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2920       };
2921     }
2922   }
2923
2924   jresult = (void *)result;
2925   return jresult;
2926 }
2927
2928
2929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2930   void * jresult ;
2931   int *arg1 = (int *) 0 ;
2932   intp *result = 0 ;
2933
2934   arg1 = (int *)jarg1;
2935   {
2936     try {
2937       result = (intp *)intp_frompointer(arg1);
2938     } catch (std::out_of_range& e) {
2939       {
2940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2941       };
2942     } catch (std::exception& e) {
2943       {
2944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2945       };
2946     } catch (Dali::DaliException e) {
2947       {
2948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2949       };
2950     } catch (...) {
2951       {
2952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2953       };
2954     }
2955   }
2956
2957   jresult = (void *)result;
2958   return jresult;
2959 }
2960
2961
2962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2963   void * jresult ;
2964   doublep *result = 0 ;
2965
2966   {
2967     try {
2968       result = (doublep *)new_doublep();
2969     } catch (std::out_of_range& e) {
2970       {
2971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2972       };
2973     } catch (std::exception& e) {
2974       {
2975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2976       };
2977     } catch (Dali::DaliException e) {
2978       {
2979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2980       };
2981     } catch (...) {
2982       {
2983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2984       };
2985     }
2986   }
2987
2988   jresult = (void *)result;
2989   return jresult;
2990 }
2991
2992
2993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2994   doublep *arg1 = (doublep *) 0 ;
2995
2996   arg1 = (doublep *)jarg1;
2997   {
2998     try {
2999       delete_doublep(arg1);
3000     } catch (std::out_of_range& e) {
3001       {
3002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3003       };
3004     } catch (std::exception& e) {
3005       {
3006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3007       };
3008     } catch (Dali::DaliException e) {
3009       {
3010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3011       };
3012     } catch (...) {
3013       {
3014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3015       };
3016     }
3017   }
3018
3019 }
3020
3021
3022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3023   doublep *arg1 = (doublep *) 0 ;
3024   double arg2 ;
3025
3026   arg1 = (doublep *)jarg1;
3027   arg2 = (double)jarg2;
3028   {
3029     try {
3030       doublep_assign(arg1,arg2);
3031     } catch (std::out_of_range& e) {
3032       {
3033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3034       };
3035     } catch (std::exception& e) {
3036       {
3037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3038       };
3039     } catch (Dali::DaliException e) {
3040       {
3041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3042       };
3043     } catch (...) {
3044       {
3045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3046       };
3047     }
3048   }
3049
3050 }
3051
3052
3053 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3054   double jresult ;
3055   doublep *arg1 = (doublep *) 0 ;
3056   double result;
3057
3058   arg1 = (doublep *)jarg1;
3059   {
3060     try {
3061       result = (double)doublep_value(arg1);
3062     } catch (std::out_of_range& e) {
3063       {
3064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3065       };
3066     } catch (std::exception& e) {
3067       {
3068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3069       };
3070     } catch (Dali::DaliException e) {
3071       {
3072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3073       };
3074     } catch (...) {
3075       {
3076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3077       };
3078     }
3079   }
3080
3081   jresult = result;
3082   return jresult;
3083 }
3084
3085
3086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3087   void * jresult ;
3088   doublep *arg1 = (doublep *) 0 ;
3089   double *result = 0 ;
3090
3091   arg1 = (doublep *)jarg1;
3092   {
3093     try {
3094       result = (double *)doublep_cast(arg1);
3095     } catch (std::out_of_range& e) {
3096       {
3097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3098       };
3099     } catch (std::exception& e) {
3100       {
3101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3102       };
3103     } catch (Dali::DaliException e) {
3104       {
3105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3106       };
3107     } catch (...) {
3108       {
3109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3110       };
3111     }
3112   }
3113
3114   jresult = (void *)result;
3115   return jresult;
3116 }
3117
3118
3119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3120   void * jresult ;
3121   double *arg1 = (double *) 0 ;
3122   doublep *result = 0 ;
3123
3124   arg1 = (double *)jarg1;
3125   {
3126     try {
3127       result = (doublep *)doublep_frompointer(arg1);
3128     } catch (std::out_of_range& e) {
3129       {
3130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3131       };
3132     } catch (std::exception& e) {
3133       {
3134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3135       };
3136     } catch (Dali::DaliException e) {
3137       {
3138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3139       };
3140     } catch (...) {
3141       {
3142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3143       };
3144     }
3145   }
3146
3147   jresult = (void *)result;
3148   return jresult;
3149 }
3150
3151
3152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3153   void * jresult ;
3154   uintp *result = 0 ;
3155
3156   {
3157     try {
3158       result = (uintp *)new_uintp();
3159     } catch (std::out_of_range& e) {
3160       {
3161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3162       };
3163     } catch (std::exception& e) {
3164       {
3165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3166       };
3167     } catch (Dali::DaliException e) {
3168       {
3169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3170       };
3171     } catch (...) {
3172       {
3173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3174       };
3175     }
3176   }
3177
3178   jresult = (void *)result;
3179   return jresult;
3180 }
3181
3182
3183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3184   uintp *arg1 = (uintp *) 0 ;
3185
3186   arg1 = (uintp *)jarg1;
3187   {
3188     try {
3189       delete_uintp(arg1);
3190     } catch (std::out_of_range& e) {
3191       {
3192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3193       };
3194     } catch (std::exception& e) {
3195       {
3196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3197       };
3198     } catch (Dali::DaliException e) {
3199       {
3200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3201       };
3202     } catch (...) {
3203       {
3204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3205       };
3206     }
3207   }
3208
3209 }
3210
3211
3212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3213   uintp *arg1 = (uintp *) 0 ;
3214   unsigned int arg2 ;
3215
3216   arg1 = (uintp *)jarg1;
3217   arg2 = (unsigned int)jarg2;
3218   {
3219     try {
3220       uintp_assign(arg1,arg2);
3221     } catch (std::out_of_range& e) {
3222       {
3223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3224       };
3225     } catch (std::exception& e) {
3226       {
3227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3228       };
3229     } catch (Dali::DaliException e) {
3230       {
3231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3232       };
3233     } catch (...) {
3234       {
3235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3236       };
3237     }
3238   }
3239
3240 }
3241
3242
3243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3244   unsigned int jresult ;
3245   uintp *arg1 = (uintp *) 0 ;
3246   unsigned int result;
3247
3248   arg1 = (uintp *)jarg1;
3249   {
3250     try {
3251       result = (unsigned int)uintp_value(arg1);
3252     } catch (std::out_of_range& e) {
3253       {
3254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3255       };
3256     } catch (std::exception& e) {
3257       {
3258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3259       };
3260     } catch (Dali::DaliException e) {
3261       {
3262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3263       };
3264     } catch (...) {
3265       {
3266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3267       };
3268     }
3269   }
3270
3271   jresult = result;
3272   return jresult;
3273 }
3274
3275
3276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3277   void * jresult ;
3278   uintp *arg1 = (uintp *) 0 ;
3279   unsigned int *result = 0 ;
3280
3281   arg1 = (uintp *)jarg1;
3282   {
3283     try {
3284       result = (unsigned int *)uintp_cast(arg1);
3285     } catch (std::out_of_range& e) {
3286       {
3287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3288       };
3289     } catch (std::exception& e) {
3290       {
3291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3292       };
3293     } catch (Dali::DaliException e) {
3294       {
3295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3296       };
3297     } catch (...) {
3298       {
3299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3300       };
3301     }
3302   }
3303
3304   jresult = (void *)result;
3305   return jresult;
3306 }
3307
3308
3309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3310   void * jresult ;
3311   unsigned int *arg1 = (unsigned int *) 0 ;
3312   uintp *result = 0 ;
3313
3314   arg1 = (unsigned int *)jarg1;
3315   {
3316     try {
3317       result = (uintp *)uintp_frompointer(arg1);
3318     } catch (std::out_of_range& e) {
3319       {
3320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3321       };
3322     } catch (std::exception& e) {
3323       {
3324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3325       };
3326     } catch (Dali::DaliException e) {
3327       {
3328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3329       };
3330     } catch (...) {
3331       {
3332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3333       };
3334     }
3335   }
3336
3337   jresult = (void *)result;
3338   return jresult;
3339 }
3340
3341
3342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3343   void * jresult ;
3344   ushortp *result = 0 ;
3345
3346   {
3347     try {
3348       result = (ushortp *)new_ushortp();
3349     } catch (std::out_of_range& e) {
3350       {
3351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3352       };
3353     } catch (std::exception& e) {
3354       {
3355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3356       };
3357     } catch (Dali::DaliException e) {
3358       {
3359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3360       };
3361     } catch (...) {
3362       {
3363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3364       };
3365     }
3366   }
3367
3368   jresult = (void *)result;
3369   return jresult;
3370 }
3371
3372
3373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3374   ushortp *arg1 = (ushortp *) 0 ;
3375
3376   arg1 = (ushortp *)jarg1;
3377   {
3378     try {
3379       delete_ushortp(arg1);
3380     } catch (std::out_of_range& e) {
3381       {
3382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3383       };
3384     } catch (std::exception& e) {
3385       {
3386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3387       };
3388     } catch (Dali::DaliException e) {
3389       {
3390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3391       };
3392     } catch (...) {
3393       {
3394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3395       };
3396     }
3397   }
3398
3399 }
3400
3401
3402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3403   ushortp *arg1 = (ushortp *) 0 ;
3404   unsigned short arg2 ;
3405
3406   arg1 = (ushortp *)jarg1;
3407   arg2 = (unsigned short)jarg2;
3408   {
3409     try {
3410       ushortp_assign(arg1,arg2);
3411     } catch (std::out_of_range& e) {
3412       {
3413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3414       };
3415     } catch (std::exception& e) {
3416       {
3417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3418       };
3419     } catch (Dali::DaliException e) {
3420       {
3421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3422       };
3423     } catch (...) {
3424       {
3425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3426       };
3427     }
3428   }
3429
3430 }
3431
3432
3433 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3434   unsigned short jresult ;
3435   ushortp *arg1 = (ushortp *) 0 ;
3436   unsigned short result;
3437
3438   arg1 = (ushortp *)jarg1;
3439   {
3440     try {
3441       result = (unsigned short)ushortp_value(arg1);
3442     } catch (std::out_of_range& e) {
3443       {
3444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3445       };
3446     } catch (std::exception& e) {
3447       {
3448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3449       };
3450     } catch (Dali::DaliException e) {
3451       {
3452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3453       };
3454     } catch (...) {
3455       {
3456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3457       };
3458     }
3459   }
3460
3461   jresult = result;
3462   return jresult;
3463 }
3464
3465
3466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3467   void * jresult ;
3468   ushortp *arg1 = (ushortp *) 0 ;
3469   unsigned short *result = 0 ;
3470
3471   arg1 = (ushortp *)jarg1;
3472   {
3473     try {
3474       result = (unsigned short *)ushortp_cast(arg1);
3475     } catch (std::out_of_range& e) {
3476       {
3477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3478       };
3479     } catch (std::exception& e) {
3480       {
3481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3482       };
3483     } catch (Dali::DaliException e) {
3484       {
3485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3486       };
3487     } catch (...) {
3488       {
3489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3490       };
3491     }
3492   }
3493
3494   jresult = (void *)result;
3495   return jresult;
3496 }
3497
3498
3499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3500   void * jresult ;
3501   unsigned short *arg1 = (unsigned short *) 0 ;
3502   ushortp *result = 0 ;
3503
3504   arg1 = (unsigned short *)jarg1;
3505   {
3506     try {
3507       result = (ushortp *)ushortp_frompointer(arg1);
3508     } catch (std::out_of_range& e) {
3509       {
3510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3511       };
3512     } catch (std::exception& e) {
3513       {
3514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3515       };
3516     } catch (Dali::DaliException e) {
3517       {
3518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3519       };
3520     } catch (...) {
3521       {
3522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3523       };
3524     }
3525   }
3526
3527   jresult = (void *)result;
3528   return jresult;
3529 }
3530
3531
3532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3533   unsigned int jresult ;
3534   int arg1 ;
3535   unsigned int result;
3536
3537   arg1 = (int)jarg1;
3538   {
3539     try {
3540       result = (unsigned int)int_to_uint(arg1);
3541     } catch (std::out_of_range& e) {
3542       {
3543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3544       };
3545     } catch (std::exception& e) {
3546       {
3547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3548       };
3549     } catch (Dali::DaliException e) {
3550       {
3551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3552       };
3553     } catch (...) {
3554       {
3555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3556       };
3557     }
3558   }
3559
3560   jresult = result;
3561   return jresult;
3562 }
3563
3564
3565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3566   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3567
3568   arg1 = (Dali::RefObject *)jarg1;
3569   {
3570     try {
3571       (arg1)->Reference();
3572     } catch (std::out_of_range& e) {
3573       {
3574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3575       };
3576     } catch (std::exception& e) {
3577       {
3578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3579       };
3580     } catch (Dali::DaliException e) {
3581       {
3582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3583       };
3584     } catch (...) {
3585       {
3586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3587       };
3588     }
3589   }
3590
3591 }
3592
3593
3594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3595   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3596
3597   arg1 = (Dali::RefObject *)jarg1;
3598   {
3599     try {
3600       (arg1)->Unreference();
3601     } catch (std::out_of_range& e) {
3602       {
3603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3604       };
3605     } catch (std::exception& e) {
3606       {
3607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3608       };
3609     } catch (Dali::DaliException e) {
3610       {
3611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3612       };
3613     } catch (...) {
3614       {
3615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3616       };
3617     }
3618   }
3619
3620 }
3621
3622
3623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3624   int jresult ;
3625   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3626   int result;
3627
3628   arg1 = (Dali::RefObject *)jarg1;
3629   {
3630     try {
3631       result = (int)(arg1)->ReferenceCount();
3632     } catch (std::out_of_range& e) {
3633       {
3634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3635       };
3636     } catch (std::exception& e) {
3637       {
3638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3639       };
3640     } catch (Dali::DaliException e) {
3641       {
3642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3643       };
3644     } catch (...) {
3645       {
3646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3647       };
3648     }
3649   }
3650
3651   jresult = result;
3652   return jresult;
3653 }
3654
3655
3656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3657   void * jresult ;
3658   Dali::Any *result = 0 ;
3659
3660   {
3661     try {
3662       result = (Dali::Any *)new Dali::Any();
3663     } catch (std::out_of_range& e) {
3664       {
3665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3666       };
3667     } catch (std::exception& e) {
3668       {
3669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3670       };
3671     } catch (Dali::DaliException e) {
3672       {
3673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3674       };
3675     } catch (...) {
3676       {
3677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3678       };
3679     }
3680   }
3681
3682   jresult = (void *)result;
3683   return jresult;
3684 }
3685
3686
3687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3688   Dali::Any *arg1 = (Dali::Any *) 0 ;
3689
3690   arg1 = (Dali::Any *)jarg1;
3691   {
3692     try {
3693       delete arg1;
3694     } catch (std::out_of_range& e) {
3695       {
3696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3697       };
3698     } catch (std::exception& e) {
3699       {
3700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3701       };
3702     } catch (Dali::DaliException e) {
3703       {
3704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3705       };
3706     } catch (...) {
3707       {
3708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3709       };
3710     }
3711   }
3712
3713 }
3714
3715
3716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3717   char *arg1 = (char *) 0 ;
3718
3719   arg1 = (char *)jarg1;
3720   {
3721     try {
3722       Dali::Any::AssertAlways((char const *)arg1);
3723     } catch (std::out_of_range& e) {
3724       {
3725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3726       };
3727     } catch (std::exception& e) {
3728       {
3729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3730       };
3731     } catch (Dali::DaliException e) {
3732       {
3733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3734       };
3735     } catch (...) {
3736       {
3737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3738       };
3739     }
3740   }
3741
3742 }
3743
3744
3745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3746   void * jresult ;
3747   Dali::Any *arg1 = 0 ;
3748   Dali::Any *result = 0 ;
3749
3750   arg1 = (Dali::Any *)jarg1;
3751   if (!arg1) {
3752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3753     return 0;
3754   }
3755   {
3756     try {
3757       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3758     } catch (std::out_of_range& e) {
3759       {
3760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3761       };
3762     } catch (std::exception& e) {
3763       {
3764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3765       };
3766     } catch (Dali::DaliException e) {
3767       {
3768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3769       };
3770     } catch (...) {
3771       {
3772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3773       };
3774     }
3775   }
3776
3777   jresult = (void *)result;
3778   return jresult;
3779 }
3780
3781
3782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3783   void * jresult ;
3784   Dali::Any *arg1 = (Dali::Any *) 0 ;
3785   Dali::Any *arg2 = 0 ;
3786   Dali::Any *result = 0 ;
3787
3788   arg1 = (Dali::Any *)jarg1;
3789   arg2 = (Dali::Any *)jarg2;
3790   if (!arg2) {
3791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3792     return 0;
3793   }
3794   {
3795     try {
3796       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3797     } catch (std::out_of_range& e) {
3798       {
3799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3800       };
3801     } catch (std::exception& e) {
3802       {
3803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3804       };
3805     } catch (Dali::DaliException e) {
3806       {
3807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3808       };
3809     } catch (...) {
3810       {
3811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3812       };
3813     }
3814   }
3815
3816   jresult = (void *)result;
3817   return jresult;
3818 }
3819
3820
3821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3822   void * jresult ;
3823   Dali::Any *arg1 = (Dali::Any *) 0 ;
3824   std::type_info *result = 0 ;
3825
3826   arg1 = (Dali::Any *)jarg1;
3827   {
3828     try {
3829       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3830     } catch (std::out_of_range& e) {
3831       {
3832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3833       };
3834     } catch (std::exception& e) {
3835       {
3836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3837       };
3838     } catch (Dali::DaliException e) {
3839       {
3840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3841       };
3842     } catch (...) {
3843       {
3844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3845       };
3846     }
3847   }
3848
3849   jresult = (void *)result;
3850   return jresult;
3851 }
3852
3853
3854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3855   unsigned int jresult ;
3856   Dali::Any *arg1 = (Dali::Any *) 0 ;
3857   bool result;
3858
3859   arg1 = (Dali::Any *)jarg1;
3860   {
3861     try {
3862       result = (bool)((Dali::Any const *)arg1)->Empty();
3863     } catch (std::out_of_range& e) {
3864       {
3865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3866       };
3867     } catch (std::exception& e) {
3868       {
3869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3870       };
3871     } catch (Dali::DaliException e) {
3872       {
3873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3874       };
3875     } catch (...) {
3876       {
3877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3878       };
3879     }
3880   }
3881
3882   jresult = result;
3883   return jresult;
3884 }
3885
3886
3887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3888   void * jresult ;
3889   std::type_info *arg1 = 0 ;
3890   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3891   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3892   Dali::Any::AnyContainerBase *result = 0 ;
3893
3894   arg1 = (std::type_info *)jarg1;
3895   if (!arg1) {
3896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3897     return 0;
3898   }
3899   arg2 = (Dali::Any::CloneFunc)jarg2;
3900   arg3 = (Dali::Any::DeleteFunc)jarg3;
3901   {
3902     try {
3903       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3904     } catch (std::out_of_range& e) {
3905       {
3906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3907       };
3908     } catch (std::exception& e) {
3909       {
3910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3911       };
3912     } catch (Dali::DaliException e) {
3913       {
3914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3915       };
3916     } catch (...) {
3917       {
3918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3919       };
3920     }
3921   }
3922
3923   jresult = (void *)result;
3924   return jresult;
3925 }
3926
3927
3928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3929   void * jresult ;
3930   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3931   std::type_info *result = 0 ;
3932
3933   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3934   {
3935     try {
3936       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3937     } catch (std::out_of_range& e) {
3938       {
3939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3940       };
3941     } catch (std::exception& e) {
3942       {
3943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3944       };
3945     } catch (Dali::DaliException e) {
3946       {
3947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3948       };
3949     } catch (...) {
3950       {
3951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3952       };
3953     }
3954   }
3955
3956   jresult = (void *)result;
3957   return jresult;
3958 }
3959
3960
3961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3962   void * jresult ;
3963   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3964   ::std::type_info *result = 0 ;
3965
3966   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3967   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3968   jresult = (void *)result;
3969   return jresult;
3970 }
3971
3972
3973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3974   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3975   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3976
3977   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3978   arg2 = (Dali::Any::CloneFunc)jarg2;
3979   if (arg1) (arg1)->mCloneFunc = arg2;
3980 }
3981
3982
3983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3984   void * jresult ;
3985   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3986   Dali::Any::CloneFunc result;
3987
3988   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3989   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3990   jresult = (void *)result;
3991   return jresult;
3992 }
3993
3994
3995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3996   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3997   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3998
3999   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4000   arg2 = (Dali::Any::DeleteFunc)jarg2;
4001   if (arg1) (arg1)->mDeleteFunc = arg2;
4002 }
4003
4004
4005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4006   void * jresult ;
4007   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4008   Dali::Any::DeleteFunc result;
4009
4010   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4011   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4012   jresult = (void *)result;
4013   return jresult;
4014 }
4015
4016
4017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4018   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4019
4020   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4021   {
4022     try {
4023       delete arg1;
4024     } catch (std::out_of_range& e) {
4025       {
4026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4027       };
4028     } catch (std::exception& e) {
4029       {
4030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4031       };
4032     } catch (Dali::DaliException e) {
4033       {
4034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4035       };
4036     } catch (...) {
4037       {
4038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4039       };
4040     }
4041   }
4042
4043 }
4044
4045
4046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4047   Dali::Any *arg1 = (Dali::Any *) 0 ;
4048   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4049
4050   arg1 = (Dali::Any *)jarg1;
4051   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4052   if (arg1) (arg1)->mContainer = arg2;
4053 }
4054
4055
4056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4057   void * jresult ;
4058   Dali::Any *arg1 = (Dali::Any *) 0 ;
4059   Dali::Any::AnyContainerBase *result = 0 ;
4060
4061   arg1 = (Dali::Any *)jarg1;
4062   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4063   jresult = (void *)result;
4064   return jresult;
4065 }
4066
4067
4068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4069   char *arg1 = (char *) 0 ;
4070   char *arg2 = (char *) 0 ;
4071
4072   arg1 = (char *)jarg1;
4073   arg2 = (char *)jarg2;
4074   {
4075     try {
4076       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4077     } catch (std::out_of_range& e) {
4078       {
4079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4080       };
4081     } catch (std::exception& e) {
4082       {
4083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4084       };
4085     } catch (Dali::DaliException e) {
4086       {
4087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4088       };
4089     } catch (...) {
4090       {
4091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4092       };
4093     }
4094   }
4095
4096 }
4097
4098
4099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4100   void * jresult ;
4101   char *arg1 = (char *) 0 ;
4102   char *arg2 = (char *) 0 ;
4103   Dali::DaliException *result = 0 ;
4104
4105   arg1 = (char *)jarg1;
4106   arg2 = (char *)jarg2;
4107   {
4108     try {
4109       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4110     } catch (std::out_of_range& e) {
4111       {
4112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4113       };
4114     } catch (std::exception& e) {
4115       {
4116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4117       };
4118     } catch (Dali::DaliException e) {
4119       {
4120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4121       };
4122     } catch (...) {
4123       {
4124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4125       };
4126     }
4127   }
4128
4129   jresult = (void *)result;
4130   return jresult;
4131 }
4132
4133
4134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4135   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4136   std::string arg2 = std::string(jarg2);
4137
4138   arg1 = (Dali::DaliException *)jarg1;
4139   {
4140     if (!arg2.empty()) {
4141       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4142     } else {
4143       arg1->location = 0;
4144     }
4145   }
4146 }
4147
4148 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4149   char * jresult ;
4150   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4151   char *result = 0 ;
4152
4153   arg1 = (Dali::DaliException *)jarg1;
4154   result = (char *) ((arg1)->location);
4155   jresult = SWIG_csharp_string_callback((const char *)result);
4156   return jresult;
4157 }
4158
4159
4160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4161   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4162   std::string arg2 = std::string(jarg2);
4163
4164   arg1 = (Dali::DaliException *)jarg1;
4165   {
4166     if (!arg2.empty()) {
4167       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4168     } else {
4169       arg1->condition = 0;
4170     }
4171   }
4172 }
4173
4174
4175 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4176   char * jresult ;
4177   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4178   char *result = 0 ;
4179
4180   arg1 = (Dali::DaliException *)jarg1;
4181   result = (char *) ((arg1)->condition);
4182   jresult = SWIG_csharp_string_callback((const char *)result);
4183   return jresult;
4184 }
4185
4186
4187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4188   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4189
4190   arg1 = (Dali::DaliException *)jarg1;
4191   {
4192     try {
4193       delete arg1;
4194     } catch (std::out_of_range& e) {
4195       {
4196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4197       };
4198     } catch (std::exception& e) {
4199       {
4200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4201       };
4202     } catch (Dali::DaliException e) {
4203       {
4204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4205       };
4206     } catch (...) {
4207       {
4208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4209       };
4210     }
4211   }
4212
4213 }
4214
4215
4216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4217   void * jresult ;
4218   Dali::Vector2 *result = 0 ;
4219
4220   {
4221     try {
4222       result = (Dali::Vector2 *)new Dali::Vector2();
4223     } catch (std::out_of_range& e) {
4224       {
4225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4226       };
4227     } catch (std::exception& e) {
4228       {
4229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4230       };
4231     } catch (Dali::DaliException e) {
4232       {
4233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4234       };
4235     } catch (...) {
4236       {
4237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4238       };
4239     }
4240   }
4241
4242   jresult = (void *)result;
4243   return jresult;
4244 }
4245
4246
4247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4248   void * jresult ;
4249   float arg1 ;
4250   float arg2 ;
4251   Dali::Vector2 *result = 0 ;
4252
4253   arg1 = (float)jarg1;
4254   arg2 = (float)jarg2;
4255   {
4256     try {
4257       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4258     } catch (std::out_of_range& e) {
4259       {
4260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4261       };
4262     } catch (std::exception& e) {
4263       {
4264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4265       };
4266     } catch (Dali::DaliException e) {
4267       {
4268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4269       };
4270     } catch (...) {
4271       {
4272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4273       };
4274     }
4275   }
4276
4277   jresult = (void *)result;
4278   return jresult;
4279 }
4280
4281
4282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4283   void * jresult ;
4284   float *arg1 = (float *) 0 ;
4285   Dali::Vector2 *result = 0 ;
4286
4287   arg1 = jarg1;
4288   {
4289     try {
4290       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4291     } catch (std::out_of_range& e) {
4292       {
4293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4294       };
4295     } catch (std::exception& e) {
4296       {
4297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4298       };
4299     } catch (Dali::DaliException e) {
4300       {
4301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4302       };
4303     } catch (...) {
4304       {
4305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4306       };
4307     }
4308   }
4309
4310   jresult = (void *)result;
4311
4312
4313   return jresult;
4314 }
4315
4316
4317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4318   void * jresult ;
4319   Dali::Vector3 *arg1 = 0 ;
4320   Dali::Vector2 *result = 0 ;
4321
4322   arg1 = (Dali::Vector3 *)jarg1;
4323   if (!arg1) {
4324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4325     return 0;
4326   }
4327   {
4328     try {
4329       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4330     } catch (std::out_of_range& e) {
4331       {
4332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4333       };
4334     } catch (std::exception& e) {
4335       {
4336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4337       };
4338     } catch (Dali::DaliException e) {
4339       {
4340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4341       };
4342     } catch (...) {
4343       {
4344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4345       };
4346     }
4347   }
4348
4349   jresult = (void *)result;
4350   return jresult;
4351 }
4352
4353
4354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4355   void * jresult ;
4356   Dali::Vector4 *arg1 = 0 ;
4357   Dali::Vector2 *result = 0 ;
4358
4359   arg1 = (Dali::Vector4 *)jarg1;
4360   if (!arg1) {
4361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4362     return 0;
4363   }
4364   {
4365     try {
4366       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4367     } catch (std::out_of_range& e) {
4368       {
4369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4370       };
4371     } catch (std::exception& e) {
4372       {
4373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4374       };
4375     } catch (Dali::DaliException e) {
4376       {
4377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4378       };
4379     } catch (...) {
4380       {
4381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4382       };
4383     }
4384   }
4385
4386   jresult = (void *)result;
4387   return jresult;
4388 }
4389
4390
4391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4392   void * jresult ;
4393   Dali::Vector2 *result = 0 ;
4394
4395   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4396   jresult = (void *)result;
4397   return jresult;
4398 }
4399
4400
4401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4402   void * jresult ;
4403   Dali::Vector2 *result = 0 ;
4404
4405   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4406   jresult = (void *)result;
4407   return jresult;
4408 }
4409
4410
4411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4412   void * jresult ;
4413   Dali::Vector2 *result = 0 ;
4414
4415   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4416   jresult = (void *)result;
4417   return jresult;
4418 }
4419
4420
4421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4422   void * jresult ;
4423   Dali::Vector2 *result = 0 ;
4424
4425   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4426   jresult = (void *)result;
4427   return jresult;
4428 }
4429
4430
4431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4432   void * jresult ;
4433   Dali::Vector2 *result = 0 ;
4434
4435   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4436   jresult = (void *)result;
4437   return jresult;
4438 }
4439
4440
4441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4442   void * jresult ;
4443   Dali::Vector2 *result = 0 ;
4444
4445   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4446   jresult = (void *)result;
4447   return jresult;
4448 }
4449
4450
4451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4452   void * jresult ;
4453   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4454   float *arg2 = (float *) 0 ;
4455   Dali::Vector2 *result = 0 ;
4456
4457   arg1 = (Dali::Vector2 *)jarg1;
4458   arg2 = jarg2;
4459   {
4460     try {
4461       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4462     } catch (std::out_of_range& e) {
4463       {
4464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4465       };
4466     } catch (std::exception& e) {
4467       {
4468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4469       };
4470     } catch (Dali::DaliException e) {
4471       {
4472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4473       };
4474     } catch (...) {
4475       {
4476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4477       };
4478     }
4479   }
4480
4481   jresult = (void *)result;
4482
4483
4484   return jresult;
4485 }
4486
4487
4488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4489   void * jresult ;
4490   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4491   Dali::Vector3 *arg2 = 0 ;
4492   Dali::Vector2 *result = 0 ;
4493
4494   arg1 = (Dali::Vector2 *)jarg1;
4495   arg2 = (Dali::Vector3 *)jarg2;
4496   if (!arg2) {
4497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4498     return 0;
4499   }
4500   {
4501     try {
4502       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4503     } catch (std::out_of_range& e) {
4504       {
4505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4506       };
4507     } catch (std::exception& e) {
4508       {
4509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4510       };
4511     } catch (Dali::DaliException e) {
4512       {
4513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4514       };
4515     } catch (...) {
4516       {
4517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4518       };
4519     }
4520   }
4521
4522   jresult = (void *)result;
4523   return jresult;
4524 }
4525
4526
4527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4528   void * jresult ;
4529   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4530   Dali::Vector4 *arg2 = 0 ;
4531   Dali::Vector2 *result = 0 ;
4532
4533   arg1 = (Dali::Vector2 *)jarg1;
4534   arg2 = (Dali::Vector4 *)jarg2;
4535   if (!arg2) {
4536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4537     return 0;
4538   }
4539   {
4540     try {
4541       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4542     } catch (std::out_of_range& e) {
4543       {
4544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4545       };
4546     } catch (std::exception& e) {
4547       {
4548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4549       };
4550     } catch (Dali::DaliException e) {
4551       {
4552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4553       };
4554     } catch (...) {
4555       {
4556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4557       };
4558     }
4559   }
4560
4561   jresult = (void *)result;
4562   return jresult;
4563 }
4564
4565
4566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4567   void * jresult ;
4568   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4569   Dali::Vector2 *arg2 = 0 ;
4570   Dali::Vector2 result;
4571
4572   arg1 = (Dali::Vector2 *)jarg1;
4573   arg2 = (Dali::Vector2 *)jarg2;
4574   if (!arg2) {
4575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4576     return 0;
4577   }
4578   {
4579     try {
4580       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4581     } catch (std::out_of_range& e) {
4582       {
4583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4584       };
4585     } catch (std::exception& e) {
4586       {
4587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4588       };
4589     } catch (Dali::DaliException e) {
4590       {
4591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4592       };
4593     } catch (...) {
4594       {
4595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4596       };
4597     }
4598   }
4599
4600   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4601   return jresult;
4602 }
4603
4604
4605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4606   void * jresult ;
4607   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4608   Dali::Vector2 *arg2 = 0 ;
4609   Dali::Vector2 *result = 0 ;
4610
4611   arg1 = (Dali::Vector2 *)jarg1;
4612   arg2 = (Dali::Vector2 *)jarg2;
4613   if (!arg2) {
4614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4615     return 0;
4616   }
4617   {
4618     try {
4619       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4620     } catch (std::out_of_range& e) {
4621       {
4622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4623       };
4624     } catch (std::exception& e) {
4625       {
4626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4627       };
4628     } catch (Dali::DaliException e) {
4629       {
4630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4631       };
4632     } catch (...) {
4633       {
4634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4635       };
4636     }
4637   }
4638
4639   jresult = (void *)result;
4640   return jresult;
4641 }
4642
4643
4644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4645   void * jresult ;
4646   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4647   Dali::Vector2 *arg2 = 0 ;
4648   Dali::Vector2 result;
4649
4650   arg1 = (Dali::Vector2 *)jarg1;
4651   arg2 = (Dali::Vector2 *)jarg2;
4652   if (!arg2) {
4653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4654     return 0;
4655   }
4656   {
4657     try {
4658       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4659     } catch (std::out_of_range& e) {
4660       {
4661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4662       };
4663     } catch (std::exception& e) {
4664       {
4665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4666       };
4667     } catch (Dali::DaliException e) {
4668       {
4669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4670       };
4671     } catch (...) {
4672       {
4673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4674       };
4675     }
4676   }
4677
4678   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4679   return jresult;
4680 }
4681
4682
4683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4684   void * jresult ;
4685   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4686   Dali::Vector2 *arg2 = 0 ;
4687   Dali::Vector2 *result = 0 ;
4688
4689   arg1 = (Dali::Vector2 *)jarg1;
4690   arg2 = (Dali::Vector2 *)jarg2;
4691   if (!arg2) {
4692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4693     return 0;
4694   }
4695   {
4696     try {
4697       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4698     } catch (std::out_of_range& e) {
4699       {
4700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4701       };
4702     } catch (std::exception& e) {
4703       {
4704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4705       };
4706     } catch (Dali::DaliException e) {
4707       {
4708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4709       };
4710     } catch (...) {
4711       {
4712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4713       };
4714     }
4715   }
4716
4717   jresult = (void *)result;
4718   return jresult;
4719 }
4720
4721
4722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4723   void * jresult ;
4724   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4725   Dali::Vector2 *arg2 = 0 ;
4726   Dali::Vector2 result;
4727
4728   arg1 = (Dali::Vector2 *)jarg1;
4729   arg2 = (Dali::Vector2 *)jarg2;
4730   if (!arg2) {
4731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4732     return 0;
4733   }
4734   {
4735     try {
4736       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4737     } catch (std::out_of_range& e) {
4738       {
4739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4740       };
4741     } catch (std::exception& e) {
4742       {
4743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4744       };
4745     } catch (Dali::DaliException e) {
4746       {
4747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4748       };
4749     } catch (...) {
4750       {
4751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4752       };
4753     }
4754   }
4755
4756   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4757   return jresult;
4758 }
4759
4760
4761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4762   void * jresult ;
4763   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4764   float arg2 ;
4765   Dali::Vector2 result;
4766
4767   arg1 = (Dali::Vector2 *)jarg1;
4768   arg2 = (float)jarg2;
4769   {
4770     try {
4771       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4772     } catch (std::out_of_range& e) {
4773       {
4774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4775       };
4776     } catch (std::exception& e) {
4777       {
4778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4779       };
4780     } catch (Dali::DaliException e) {
4781       {
4782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4783       };
4784     } catch (...) {
4785       {
4786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4787       };
4788     }
4789   }
4790
4791   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4792   return jresult;
4793 }
4794
4795
4796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4797   void * jresult ;
4798   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4799   Dali::Vector2 *arg2 = 0 ;
4800   Dali::Vector2 *result = 0 ;
4801
4802   arg1 = (Dali::Vector2 *)jarg1;
4803   arg2 = (Dali::Vector2 *)jarg2;
4804   if (!arg2) {
4805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4806     return 0;
4807   }
4808   {
4809     try {
4810       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4811     } catch (std::out_of_range& e) {
4812       {
4813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4814       };
4815     } catch (std::exception& e) {
4816       {
4817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4818       };
4819     } catch (Dali::DaliException e) {
4820       {
4821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4822       };
4823     } catch (...) {
4824       {
4825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4826       };
4827     }
4828   }
4829
4830   jresult = (void *)result;
4831   return jresult;
4832 }
4833
4834
4835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4836   void * jresult ;
4837   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4838   float arg2 ;
4839   Dali::Vector2 *result = 0 ;
4840
4841   arg1 = (Dali::Vector2 *)jarg1;
4842   arg2 = (float)jarg2;
4843   {
4844     try {
4845       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4846     } catch (std::out_of_range& e) {
4847       {
4848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4849       };
4850     } catch (std::exception& e) {
4851       {
4852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4853       };
4854     } catch (Dali::DaliException e) {
4855       {
4856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4857       };
4858     } catch (...) {
4859       {
4860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4861       };
4862     }
4863   }
4864
4865   jresult = (void *)result;
4866   return jresult;
4867 }
4868
4869
4870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4871   void * jresult ;
4872   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4873   Dali::Vector2 *arg2 = 0 ;
4874   Dali::Vector2 result;
4875
4876   arg1 = (Dali::Vector2 *)jarg1;
4877   arg2 = (Dali::Vector2 *)jarg2;
4878   if (!arg2) {
4879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4880     return 0;
4881   }
4882   {
4883     try {
4884       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4885     } catch (std::out_of_range& e) {
4886       {
4887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4888       };
4889     } catch (std::exception& e) {
4890       {
4891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4892       };
4893     } catch (Dali::DaliException e) {
4894       {
4895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4896       };
4897     } catch (...) {
4898       {
4899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4900       };
4901     }
4902   }
4903
4904   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4905   return jresult;
4906 }
4907
4908
4909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4910   void * jresult ;
4911   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4912   float arg2 ;
4913   Dali::Vector2 result;
4914
4915   arg1 = (Dali::Vector2 *)jarg1;
4916   arg2 = (float)jarg2;
4917   {
4918     try {
4919       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4920     } catch (std::out_of_range& e) {
4921       {
4922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4923       };
4924     } catch (std::exception& e) {
4925       {
4926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4927       };
4928     } catch (Dali::DaliException e) {
4929       {
4930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4931       };
4932     } catch (...) {
4933       {
4934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4935       };
4936     }
4937   }
4938
4939   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4940   return jresult;
4941 }
4942
4943
4944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4945   void * jresult ;
4946   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4947   Dali::Vector2 *arg2 = 0 ;
4948   Dali::Vector2 *result = 0 ;
4949
4950   arg1 = (Dali::Vector2 *)jarg1;
4951   arg2 = (Dali::Vector2 *)jarg2;
4952   if (!arg2) {
4953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4954     return 0;
4955   }
4956   {
4957     try {
4958       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4959     } catch (std::out_of_range& e) {
4960       {
4961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4962       };
4963     } catch (std::exception& e) {
4964       {
4965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4966       };
4967     } catch (Dali::DaliException e) {
4968       {
4969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4970       };
4971     } catch (...) {
4972       {
4973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4974       };
4975     }
4976   }
4977
4978   jresult = (void *)result;
4979   return jresult;
4980 }
4981
4982
4983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4984   void * jresult ;
4985   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4986   float arg2 ;
4987   Dali::Vector2 *result = 0 ;
4988
4989   arg1 = (Dali::Vector2 *)jarg1;
4990   arg2 = (float)jarg2;
4991   {
4992     try {
4993       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4994     } catch (std::out_of_range& e) {
4995       {
4996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4997       };
4998     } catch (std::exception& e) {
4999       {
5000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5001       };
5002     } catch (Dali::DaliException e) {
5003       {
5004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5005       };
5006     } catch (...) {
5007       {
5008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5009       };
5010     }
5011   }
5012
5013   jresult = (void *)result;
5014   return jresult;
5015 }
5016
5017
5018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5019   void * jresult ;
5020   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5021   Dali::Vector2 result;
5022
5023   arg1 = (Dali::Vector2 *)jarg1;
5024   {
5025     try {
5026       result = ((Dali::Vector2 const *)arg1)->operator -();
5027     } catch (std::out_of_range& e) {
5028       {
5029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5030       };
5031     } catch (std::exception& e) {
5032       {
5033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5034       };
5035     } catch (Dali::DaliException e) {
5036       {
5037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5038       };
5039     } catch (...) {
5040       {
5041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5042       };
5043     }
5044   }
5045
5046   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5047   return jresult;
5048 }
5049
5050
5051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5052   unsigned int jresult ;
5053   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5054   Dali::Vector2 *arg2 = 0 ;
5055   bool result;
5056
5057   arg1 = (Dali::Vector2 *)jarg1;
5058   arg2 = (Dali::Vector2 *)jarg2;
5059   if (!arg2) {
5060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5061     return 0;
5062   }
5063   {
5064     try {
5065       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5066     } catch (std::out_of_range& e) {
5067       {
5068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5069       };
5070     } catch (std::exception& e) {
5071       {
5072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5073       };
5074     } catch (Dali::DaliException e) {
5075       {
5076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5077       };
5078     } catch (...) {
5079       {
5080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5081       };
5082     }
5083   }
5084
5085   jresult = result;
5086   return jresult;
5087 }
5088
5089
5090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5091   unsigned int jresult ;
5092   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5093   Dali::Vector2 *arg2 = 0 ;
5094   bool result;
5095
5096   arg1 = (Dali::Vector2 *)jarg1;
5097   arg2 = (Dali::Vector2 *)jarg2;
5098   if (!arg2) {
5099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5100     return 0;
5101   }
5102   {
5103     try {
5104       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5105     } catch (std::out_of_range& e) {
5106       {
5107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5108       };
5109     } catch (std::exception& e) {
5110       {
5111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5112       };
5113     } catch (Dali::DaliException e) {
5114       {
5115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5116       };
5117     } catch (...) {
5118       {
5119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5120       };
5121     }
5122   }
5123
5124   jresult = result;
5125   return jresult;
5126 }
5127
5128
5129 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5130   float jresult ;
5131   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5132   unsigned int arg2 ;
5133   float *result = 0 ;
5134
5135   arg1 = (Dali::Vector2 *)jarg1;
5136   arg2 = (unsigned int)jarg2;
5137   {
5138     try {
5139       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5140     } catch (std::out_of_range& e) {
5141       {
5142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5143       };
5144     } catch (std::exception& e) {
5145       {
5146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5147       };
5148     } catch (Dali::DaliException e) {
5149       {
5150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5151       };
5152     } catch (...) {
5153       {
5154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5155       };
5156     }
5157   }
5158
5159   jresult = *result;
5160   return jresult;
5161 }
5162
5163
5164 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5165   float jresult ;
5166   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5167   float result;
5168
5169   arg1 = (Dali::Vector2 *)jarg1;
5170   {
5171     try {
5172       result = (float)((Dali::Vector2 const *)arg1)->Length();
5173     } catch (std::out_of_range& e) {
5174       {
5175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5176       };
5177     } catch (std::exception& e) {
5178       {
5179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5180       };
5181     } catch (Dali::DaliException e) {
5182       {
5183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5184       };
5185     } catch (...) {
5186       {
5187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5188       };
5189     }
5190   }
5191
5192   jresult = result;
5193   return jresult;
5194 }
5195
5196
5197 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5198   float jresult ;
5199   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5200   float result;
5201
5202   arg1 = (Dali::Vector2 *)jarg1;
5203   {
5204     try {
5205       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5206     } catch (std::out_of_range& e) {
5207       {
5208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5209       };
5210     } catch (std::exception& e) {
5211       {
5212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5213       };
5214     } catch (Dali::DaliException e) {
5215       {
5216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5217       };
5218     } catch (...) {
5219       {
5220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5221       };
5222     }
5223   }
5224
5225   jresult = result;
5226   return jresult;
5227 }
5228
5229
5230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5231   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5232
5233   arg1 = (Dali::Vector2 *)jarg1;
5234   {
5235     try {
5236       (arg1)->Normalize();
5237     } catch (std::out_of_range& e) {
5238       {
5239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5240       };
5241     } catch (std::exception& e) {
5242       {
5243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5244       };
5245     } catch (Dali::DaliException e) {
5246       {
5247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5248       };
5249     } catch (...) {
5250       {
5251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5252       };
5253     }
5254   }
5255
5256 }
5257
5258
5259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5260   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5261   Dali::Vector2 *arg2 = 0 ;
5262   Dali::Vector2 *arg3 = 0 ;
5263
5264   arg1 = (Dali::Vector2 *)jarg1;
5265   arg2 = (Dali::Vector2 *)jarg2;
5266   if (!arg2) {
5267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5268     return ;
5269   }
5270   arg3 = (Dali::Vector2 *)jarg3;
5271   if (!arg3) {
5272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5273     return ;
5274   }
5275   {
5276     try {
5277       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5278     } catch (std::out_of_range& e) {
5279       {
5280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5281       };
5282     } catch (std::exception& e) {
5283       {
5284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5285       };
5286     } catch (Dali::DaliException e) {
5287       {
5288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5289       };
5290     } catch (...) {
5291       {
5292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5293       };
5294     }
5295   }
5296
5297 }
5298
5299
5300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5301   void * jresult ;
5302   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5303   float *result = 0 ;
5304
5305   arg1 = (Dali::Vector2 *)jarg1;
5306   {
5307     try {
5308       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5309     } catch (std::out_of_range& e) {
5310       {
5311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5312       };
5313     } catch (std::exception& e) {
5314       {
5315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5316       };
5317     } catch (Dali::DaliException e) {
5318       {
5319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5320       };
5321     } catch (...) {
5322       {
5323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5324       };
5325     }
5326   }
5327
5328   jresult = (void *)result;
5329   return jresult;
5330 }
5331
5332
5333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5334   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5335   float arg2 ;
5336
5337   arg1 = (Dali::Vector2 *)jarg1;
5338   arg2 = (float)jarg2;
5339   if (arg1) (arg1)->x = arg2;
5340 }
5341
5342
5343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5344   float jresult ;
5345   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5346   float result;
5347
5348   arg1 = (Dali::Vector2 *)jarg1;
5349   result = (float) ((arg1)->x);
5350   jresult = result;
5351   return jresult;
5352 }
5353
5354
5355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5356   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5357   float arg2 ;
5358
5359   arg1 = (Dali::Vector2 *)jarg1;
5360   arg2 = (float)jarg2;
5361   if (arg1) (arg1)->width = arg2;
5362 }
5363
5364
5365 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5366   float jresult ;
5367   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5368   float result;
5369
5370   arg1 = (Dali::Vector2 *)jarg1;
5371   result = (float) ((arg1)->width);
5372   jresult = result;
5373   return jresult;
5374 }
5375
5376
5377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5378   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5379   float arg2 ;
5380
5381   arg1 = (Dali::Vector2 *)jarg1;
5382   arg2 = (float)jarg2;
5383   if (arg1) (arg1)->y = arg2;
5384 }
5385
5386
5387 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5388   float jresult ;
5389   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5390   float result;
5391
5392   arg1 = (Dali::Vector2 *)jarg1;
5393   result = (float) ((arg1)->y);
5394   jresult = result;
5395   return jresult;
5396 }
5397
5398
5399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5400   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5401   float arg2 ;
5402
5403   arg1 = (Dali::Vector2 *)jarg1;
5404   arg2 = (float)jarg2;
5405   if (arg1) (arg1)->height = arg2;
5406 }
5407
5408
5409 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5410   float jresult ;
5411   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5412   float result;
5413
5414   arg1 = (Dali::Vector2 *)jarg1;
5415   result = (float) ((arg1)->height);
5416   jresult = result;
5417   return jresult;
5418 }
5419
5420
5421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5422   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5423
5424   arg1 = (Dali::Vector2 *)jarg1;
5425   {
5426     try {
5427       delete arg1;
5428     } catch (std::out_of_range& e) {
5429       {
5430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5431       };
5432     } catch (std::exception& e) {
5433       {
5434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5435       };
5436     } catch (Dali::DaliException e) {
5437       {
5438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5439       };
5440     } catch (...) {
5441       {
5442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5443       };
5444     }
5445   }
5446
5447 }
5448
5449
5450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5451   void * jresult ;
5452   Dali::Vector2 *arg1 = 0 ;
5453   Dali::Vector2 *arg2 = 0 ;
5454   Dali::Vector2 result;
5455
5456   arg1 = (Dali::Vector2 *)jarg1;
5457   if (!arg1) {
5458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5459     return 0;
5460   }
5461   arg2 = (Dali::Vector2 *)jarg2;
5462   if (!arg2) {
5463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5464     return 0;
5465   }
5466   {
5467     try {
5468       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5469     } catch (std::out_of_range& e) {
5470       {
5471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5472       };
5473     } catch (std::exception& e) {
5474       {
5475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5476       };
5477     } catch (Dali::DaliException e) {
5478       {
5479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5480       };
5481     } catch (...) {
5482       {
5483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5484       };
5485     }
5486   }
5487
5488   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5489   return jresult;
5490 }
5491
5492
5493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5494   void * jresult ;
5495   Dali::Vector2 *arg1 = 0 ;
5496   Dali::Vector2 *arg2 = 0 ;
5497   Dali::Vector2 result;
5498
5499   arg1 = (Dali::Vector2 *)jarg1;
5500   if (!arg1) {
5501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5502     return 0;
5503   }
5504   arg2 = (Dali::Vector2 *)jarg2;
5505   if (!arg2) {
5506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5507     return 0;
5508   }
5509   {
5510     try {
5511       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5512     } catch (std::out_of_range& e) {
5513       {
5514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5515       };
5516     } catch (std::exception& e) {
5517       {
5518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5519       };
5520     } catch (Dali::DaliException e) {
5521       {
5522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5523       };
5524     } catch (...) {
5525       {
5526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5527       };
5528     }
5529   }
5530
5531   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5532   return jresult;
5533 }
5534
5535
5536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5537   void * jresult ;
5538   Dali::Vector2 *arg1 = 0 ;
5539   float *arg2 = 0 ;
5540   float *arg3 = 0 ;
5541   float temp2 ;
5542   float temp3 ;
5543   Dali::Vector2 result;
5544
5545   arg1 = (Dali::Vector2 *)jarg1;
5546   if (!arg1) {
5547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5548     return 0;
5549   }
5550   temp2 = (float)jarg2;
5551   arg2 = &temp2;
5552   temp3 = (float)jarg3;
5553   arg3 = &temp3;
5554   {
5555     try {
5556       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5557     } catch (std::out_of_range& e) {
5558       {
5559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5560       };
5561     } catch (std::exception& e) {
5562       {
5563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5564       };
5565     } catch (Dali::DaliException e) {
5566       {
5567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5568       };
5569     } catch (...) {
5570       {
5571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5572       };
5573     }
5574   }
5575
5576   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5577   return jresult;
5578 }
5579
5580
5581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5582   void * jresult ;
5583   Dali::Vector3 *result = 0 ;
5584
5585   {
5586     try {
5587       result = (Dali::Vector3 *)new Dali::Vector3();
5588     } catch (std::out_of_range& e) {
5589       {
5590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5591       };
5592     } catch (std::exception& e) {
5593       {
5594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5595       };
5596     } catch (Dali::DaliException e) {
5597       {
5598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5599       };
5600     } catch (...) {
5601       {
5602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5603       };
5604     }
5605   }
5606
5607   jresult = (void *)result;
5608   return jresult;
5609 }
5610
5611
5612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5613   void * jresult ;
5614   float arg1 ;
5615   float arg2 ;
5616   float arg3 ;
5617   Dali::Vector3 *result = 0 ;
5618
5619   arg1 = (float)jarg1;
5620   arg2 = (float)jarg2;
5621   arg3 = (float)jarg3;
5622   {
5623     try {
5624       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5625     } catch (std::out_of_range& e) {
5626       {
5627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5628       };
5629     } catch (std::exception& e) {
5630       {
5631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5632       };
5633     } catch (Dali::DaliException e) {
5634       {
5635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5636       };
5637     } catch (...) {
5638       {
5639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5640       };
5641     }
5642   }
5643
5644   jresult = (void *)result;
5645   return jresult;
5646 }
5647
5648
5649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5650   void * jresult ;
5651   float *arg1 = (float *) 0 ;
5652   Dali::Vector3 *result = 0 ;
5653
5654   arg1 = jarg1;
5655   {
5656     try {
5657       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5658     } catch (std::out_of_range& e) {
5659       {
5660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5661       };
5662     } catch (std::exception& e) {
5663       {
5664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5665       };
5666     } catch (Dali::DaliException e) {
5667       {
5668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5669       };
5670     } catch (...) {
5671       {
5672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5673       };
5674     }
5675   }
5676
5677   jresult = (void *)result;
5678
5679
5680   return jresult;
5681 }
5682
5683
5684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5685   void * jresult ;
5686   Dali::Vector2 *arg1 = 0 ;
5687   Dali::Vector3 *result = 0 ;
5688
5689   arg1 = (Dali::Vector2 *)jarg1;
5690   if (!arg1) {
5691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5692     return 0;
5693   }
5694   {
5695     try {
5696       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5697     } catch (std::out_of_range& e) {
5698       {
5699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5700       };
5701     } catch (std::exception& e) {
5702       {
5703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5704       };
5705     } catch (Dali::DaliException e) {
5706       {
5707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5708       };
5709     } catch (...) {
5710       {
5711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5712       };
5713     }
5714   }
5715
5716   jresult = (void *)result;
5717   return jresult;
5718 }
5719
5720
5721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5722   void * jresult ;
5723   Dali::Vector4 *arg1 = 0 ;
5724   Dali::Vector3 *result = 0 ;
5725
5726   arg1 = (Dali::Vector4 *)jarg1;
5727   if (!arg1) {
5728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5729     return 0;
5730   }
5731   {
5732     try {
5733       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5734     } catch (std::out_of_range& e) {
5735       {
5736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5737       };
5738     } catch (std::exception& e) {
5739       {
5740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5741       };
5742     } catch (Dali::DaliException e) {
5743       {
5744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5745       };
5746     } catch (...) {
5747       {
5748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5749       };
5750     }
5751   }
5752
5753   jresult = (void *)result;
5754   return jresult;
5755 }
5756
5757
5758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5759   void * jresult ;
5760   Dali::Vector3 *result = 0 ;
5761
5762   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5763   jresult = (void *)result;
5764   return jresult;
5765 }
5766
5767
5768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5769   void * jresult ;
5770   Dali::Vector3 *result = 0 ;
5771
5772   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5773   jresult = (void *)result;
5774   return jresult;
5775 }
5776
5777
5778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5779   void * jresult ;
5780   Dali::Vector3 *result = 0 ;
5781
5782   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5783   jresult = (void *)result;
5784   return jresult;
5785 }
5786
5787
5788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5789   void * jresult ;
5790   Dali::Vector3 *result = 0 ;
5791
5792   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5793   jresult = (void *)result;
5794   return jresult;
5795 }
5796
5797
5798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5799   void * jresult ;
5800   Dali::Vector3 *result = 0 ;
5801
5802   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5803   jresult = (void *)result;
5804   return jresult;
5805 }
5806
5807
5808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5809   void * jresult ;
5810   Dali::Vector3 *result = 0 ;
5811
5812   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5813   jresult = (void *)result;
5814   return jresult;
5815 }
5816
5817
5818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5819   void * jresult ;
5820   Dali::Vector3 *result = 0 ;
5821
5822   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5823   jresult = (void *)result;
5824   return jresult;
5825 }
5826
5827
5828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5829   void * jresult ;
5830   Dali::Vector3 *result = 0 ;
5831
5832   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5833   jresult = (void *)result;
5834   return jresult;
5835 }
5836
5837
5838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5839   void * jresult ;
5840   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5841   float *arg2 = (float *) 0 ;
5842   Dali::Vector3 *result = 0 ;
5843
5844   arg1 = (Dali::Vector3 *)jarg1;
5845   arg2 = jarg2;
5846   {
5847     try {
5848       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5849     } catch (std::out_of_range& e) {
5850       {
5851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5852       };
5853     } catch (std::exception& e) {
5854       {
5855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5856       };
5857     } catch (Dali::DaliException e) {
5858       {
5859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5860       };
5861     } catch (...) {
5862       {
5863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5864       };
5865     }
5866   }
5867
5868   jresult = (void *)result;
5869
5870
5871   return jresult;
5872 }
5873
5874
5875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5876   void * jresult ;
5877   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5878   Dali::Vector2 *arg2 = 0 ;
5879   Dali::Vector3 *result = 0 ;
5880
5881   arg1 = (Dali::Vector3 *)jarg1;
5882   arg2 = (Dali::Vector2 *)jarg2;
5883   if (!arg2) {
5884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5885     return 0;
5886   }
5887   {
5888     try {
5889       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5890     } catch (std::out_of_range& e) {
5891       {
5892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5893       };
5894     } catch (std::exception& e) {
5895       {
5896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5897       };
5898     } catch (Dali::DaliException e) {
5899       {
5900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5901       };
5902     } catch (...) {
5903       {
5904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5905       };
5906     }
5907   }
5908
5909   jresult = (void *)result;
5910   return jresult;
5911 }
5912
5913
5914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5915   void * jresult ;
5916   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5917   Dali::Vector4 *arg2 = 0 ;
5918   Dali::Vector3 *result = 0 ;
5919
5920   arg1 = (Dali::Vector3 *)jarg1;
5921   arg2 = (Dali::Vector4 *)jarg2;
5922   if (!arg2) {
5923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5924     return 0;
5925   }
5926   {
5927     try {
5928       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5929     } catch (std::out_of_range& e) {
5930       {
5931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5932       };
5933     } catch (std::exception& e) {
5934       {
5935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5936       };
5937     } catch (Dali::DaliException e) {
5938       {
5939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5940       };
5941     } catch (...) {
5942       {
5943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5944       };
5945     }
5946   }
5947
5948   jresult = (void *)result;
5949   return jresult;
5950 }
5951
5952
5953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5954   void * jresult ;
5955   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5956   Dali::Vector3 *arg2 = 0 ;
5957   Dali::Vector3 result;
5958
5959   arg1 = (Dali::Vector3 *)jarg1;
5960   arg2 = (Dali::Vector3 *)jarg2;
5961   if (!arg2) {
5962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5963     return 0;
5964   }
5965   {
5966     try {
5967       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5968     } catch (std::out_of_range& e) {
5969       {
5970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5971       };
5972     } catch (std::exception& e) {
5973       {
5974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5975       };
5976     } catch (Dali::DaliException e) {
5977       {
5978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5979       };
5980     } catch (...) {
5981       {
5982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5983       };
5984     }
5985   }
5986
5987   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5988   return jresult;
5989 }
5990
5991
5992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5993   void * jresult ;
5994   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5995   Dali::Vector3 *arg2 = 0 ;
5996   Dali::Vector3 *result = 0 ;
5997
5998   arg1 = (Dali::Vector3 *)jarg1;
5999   arg2 = (Dali::Vector3 *)jarg2;
6000   if (!arg2) {
6001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6002     return 0;
6003   }
6004   {
6005     try {
6006       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6007     } catch (std::out_of_range& e) {
6008       {
6009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6010       };
6011     } catch (std::exception& e) {
6012       {
6013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6014       };
6015     } catch (Dali::DaliException e) {
6016       {
6017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6018       };
6019     } catch (...) {
6020       {
6021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6022       };
6023     }
6024   }
6025
6026   jresult = (void *)result;
6027   return jresult;
6028 }
6029
6030
6031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6032   void * jresult ;
6033   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6034   Dali::Vector3 *arg2 = 0 ;
6035   Dali::Vector3 result;
6036
6037   arg1 = (Dali::Vector3 *)jarg1;
6038   arg2 = (Dali::Vector3 *)jarg2;
6039   if (!arg2) {
6040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6041     return 0;
6042   }
6043   {
6044     try {
6045       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6046     } catch (std::out_of_range& e) {
6047       {
6048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6049       };
6050     } catch (std::exception& e) {
6051       {
6052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6053       };
6054     } catch (Dali::DaliException e) {
6055       {
6056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6057       };
6058     } catch (...) {
6059       {
6060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6061       };
6062     }
6063   }
6064
6065   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6066   return jresult;
6067 }
6068
6069
6070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6071   void * jresult ;
6072   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6073   Dali::Vector3 *arg2 = 0 ;
6074   Dali::Vector3 *result = 0 ;
6075
6076   arg1 = (Dali::Vector3 *)jarg1;
6077   arg2 = (Dali::Vector3 *)jarg2;
6078   if (!arg2) {
6079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6080     return 0;
6081   }
6082   {
6083     try {
6084       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6085     } catch (std::out_of_range& e) {
6086       {
6087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6088       };
6089     } catch (std::exception& e) {
6090       {
6091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6092       };
6093     } catch (Dali::DaliException e) {
6094       {
6095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6096       };
6097     } catch (...) {
6098       {
6099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6100       };
6101     }
6102   }
6103
6104   jresult = (void *)result;
6105   return jresult;
6106 }
6107
6108
6109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6110   void * jresult ;
6111   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6112   Dali::Vector3 *arg2 = 0 ;
6113   Dali::Vector3 result;
6114
6115   arg1 = (Dali::Vector3 *)jarg1;
6116   arg2 = (Dali::Vector3 *)jarg2;
6117   if (!arg2) {
6118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6119     return 0;
6120   }
6121   {
6122     try {
6123       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6124     } catch (std::out_of_range& e) {
6125       {
6126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6127       };
6128     } catch (std::exception& e) {
6129       {
6130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6131       };
6132     } catch (Dali::DaliException e) {
6133       {
6134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6135       };
6136     } catch (...) {
6137       {
6138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6139       };
6140     }
6141   }
6142
6143   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6144   return jresult;
6145 }
6146
6147
6148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6149   void * jresult ;
6150   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6151   float arg2 ;
6152   Dali::Vector3 result;
6153
6154   arg1 = (Dali::Vector3 *)jarg1;
6155   arg2 = (float)jarg2;
6156   {
6157     try {
6158       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6159     } catch (std::out_of_range& e) {
6160       {
6161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6162       };
6163     } catch (std::exception& e) {
6164       {
6165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6166       };
6167     } catch (Dali::DaliException e) {
6168       {
6169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6170       };
6171     } catch (...) {
6172       {
6173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6174       };
6175     }
6176   }
6177
6178   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6179   return jresult;
6180 }
6181
6182
6183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6184   void * jresult ;
6185   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6186   Dali::Vector3 *arg2 = 0 ;
6187   Dali::Vector3 *result = 0 ;
6188
6189   arg1 = (Dali::Vector3 *)jarg1;
6190   arg2 = (Dali::Vector3 *)jarg2;
6191   if (!arg2) {
6192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6193     return 0;
6194   }
6195   {
6196     try {
6197       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6198     } catch (std::out_of_range& e) {
6199       {
6200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6201       };
6202     } catch (std::exception& e) {
6203       {
6204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6205       };
6206     } catch (Dali::DaliException e) {
6207       {
6208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6209       };
6210     } catch (...) {
6211       {
6212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6213       };
6214     }
6215   }
6216
6217   jresult = (void *)result;
6218   return jresult;
6219 }
6220
6221
6222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6223   void * jresult ;
6224   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6225   float arg2 ;
6226   Dali::Vector3 *result = 0 ;
6227
6228   arg1 = (Dali::Vector3 *)jarg1;
6229   arg2 = (float)jarg2;
6230   {
6231     try {
6232       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6233     } catch (std::out_of_range& e) {
6234       {
6235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6236       };
6237     } catch (std::exception& e) {
6238       {
6239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6240       };
6241     } catch (Dali::DaliException e) {
6242       {
6243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6244       };
6245     } catch (...) {
6246       {
6247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6248       };
6249     }
6250   }
6251
6252   jresult = (void *)result;
6253   return jresult;
6254 }
6255
6256
6257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6258   void * jresult ;
6259   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6260   Dali::Quaternion *arg2 = 0 ;
6261   Dali::Vector3 *result = 0 ;
6262
6263   arg1 = (Dali::Vector3 *)jarg1;
6264   arg2 = (Dali::Quaternion *)jarg2;
6265   if (!arg2) {
6266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6267     return 0;
6268   }
6269   {
6270     try {
6271       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6272     } catch (std::out_of_range& e) {
6273       {
6274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6275       };
6276     } catch (std::exception& e) {
6277       {
6278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6279       };
6280     } catch (Dali::DaliException e) {
6281       {
6282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6283       };
6284     } catch (...) {
6285       {
6286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6287       };
6288     }
6289   }
6290
6291   jresult = (void *)result;
6292   return jresult;
6293 }
6294
6295
6296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6297   void * jresult ;
6298   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6299   Dali::Vector3 *arg2 = 0 ;
6300   Dali::Vector3 result;
6301
6302   arg1 = (Dali::Vector3 *)jarg1;
6303   arg2 = (Dali::Vector3 *)jarg2;
6304   if (!arg2) {
6305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6306     return 0;
6307   }
6308   {
6309     try {
6310       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6311     } catch (std::out_of_range& e) {
6312       {
6313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6314       };
6315     } catch (std::exception& e) {
6316       {
6317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6318       };
6319     } catch (Dali::DaliException e) {
6320       {
6321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6322       };
6323     } catch (...) {
6324       {
6325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6326       };
6327     }
6328   }
6329
6330   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6331   return jresult;
6332 }
6333
6334
6335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6336   void * jresult ;
6337   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6338   float arg2 ;
6339   Dali::Vector3 result;
6340
6341   arg1 = (Dali::Vector3 *)jarg1;
6342   arg2 = (float)jarg2;
6343   {
6344     try {
6345       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6346     } catch (std::out_of_range& e) {
6347       {
6348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6349       };
6350     } catch (std::exception& e) {
6351       {
6352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6353       };
6354     } catch (Dali::DaliException e) {
6355       {
6356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6357       };
6358     } catch (...) {
6359       {
6360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6361       };
6362     }
6363   }
6364
6365   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6366   return jresult;
6367 }
6368
6369
6370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6371   void * jresult ;
6372   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6373   Dali::Vector3 *arg2 = 0 ;
6374   Dali::Vector3 *result = 0 ;
6375
6376   arg1 = (Dali::Vector3 *)jarg1;
6377   arg2 = (Dali::Vector3 *)jarg2;
6378   if (!arg2) {
6379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6380     return 0;
6381   }
6382   {
6383     try {
6384       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6385     } catch (std::out_of_range& e) {
6386       {
6387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6388       };
6389     } catch (std::exception& e) {
6390       {
6391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6392       };
6393     } catch (Dali::DaliException e) {
6394       {
6395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6396       };
6397     } catch (...) {
6398       {
6399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6400       };
6401     }
6402   }
6403
6404   jresult = (void *)result;
6405   return jresult;
6406 }
6407
6408
6409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6410   void * jresult ;
6411   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6412   float arg2 ;
6413   Dali::Vector3 *result = 0 ;
6414
6415   arg1 = (Dali::Vector3 *)jarg1;
6416   arg2 = (float)jarg2;
6417   {
6418     try {
6419       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6420     } catch (std::out_of_range& e) {
6421       {
6422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6423       };
6424     } catch (std::exception& e) {
6425       {
6426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6427       };
6428     } catch (Dali::DaliException e) {
6429       {
6430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6431       };
6432     } catch (...) {
6433       {
6434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6435       };
6436     }
6437   }
6438
6439   jresult = (void *)result;
6440   return jresult;
6441 }
6442
6443
6444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6445   void * jresult ;
6446   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6447   Dali::Vector3 result;
6448
6449   arg1 = (Dali::Vector3 *)jarg1;
6450   {
6451     try {
6452       result = ((Dali::Vector3 const *)arg1)->operator -();
6453     } catch (std::out_of_range& e) {
6454       {
6455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6456       };
6457     } catch (std::exception& e) {
6458       {
6459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6460       };
6461     } catch (Dali::DaliException e) {
6462       {
6463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6464       };
6465     } catch (...) {
6466       {
6467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6468       };
6469     }
6470   }
6471
6472   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6473   return jresult;
6474 }
6475
6476
6477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6478   unsigned int jresult ;
6479   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6480   Dali::Vector3 *arg2 = 0 ;
6481   bool result;
6482
6483   arg1 = (Dali::Vector3 *)jarg1;
6484   arg2 = (Dali::Vector3 *)jarg2;
6485   if (!arg2) {
6486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6487     return 0;
6488   }
6489   {
6490     try {
6491       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6492     } catch (std::out_of_range& e) {
6493       {
6494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6495       };
6496     } catch (std::exception& e) {
6497       {
6498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6499       };
6500     } catch (Dali::DaliException e) {
6501       {
6502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6503       };
6504     } catch (...) {
6505       {
6506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6507       };
6508     }
6509   }
6510
6511   jresult = result;
6512   return jresult;
6513 }
6514
6515
6516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6517   unsigned int jresult ;
6518   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6519   Dali::Vector3 *arg2 = 0 ;
6520   bool result;
6521
6522   arg1 = (Dali::Vector3 *)jarg1;
6523   arg2 = (Dali::Vector3 *)jarg2;
6524   if (!arg2) {
6525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6526     return 0;
6527   }
6528   {
6529     try {
6530       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6531     } catch (std::out_of_range& e) {
6532       {
6533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6534       };
6535     } catch (std::exception& e) {
6536       {
6537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6538       };
6539     } catch (Dali::DaliException e) {
6540       {
6541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6542       };
6543     } catch (...) {
6544       {
6545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6546       };
6547     }
6548   }
6549
6550   jresult = result;
6551   return jresult;
6552 }
6553
6554
6555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6556   float jresult ;
6557   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6558   unsigned int arg2 ;
6559   float *result = 0 ;
6560
6561   arg1 = (Dali::Vector3 *)jarg1;
6562   arg2 = (unsigned int)jarg2;
6563   {
6564     try {
6565       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6566     } catch (std::out_of_range& e) {
6567       {
6568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6569       };
6570     } catch (std::exception& e) {
6571       {
6572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6573       };
6574     } catch (Dali::DaliException e) {
6575       {
6576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6577       };
6578     } catch (...) {
6579       {
6580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6581       };
6582     }
6583   }
6584
6585   jresult = *result;
6586   return jresult;
6587 }
6588
6589
6590 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6591   float jresult ;
6592   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6593   Dali::Vector3 *arg2 = 0 ;
6594   float result;
6595
6596   arg1 = (Dali::Vector3 *)jarg1;
6597   arg2 = (Dali::Vector3 *)jarg2;
6598   if (!arg2) {
6599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6600     return 0;
6601   }
6602   {
6603     try {
6604       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6605     } catch (std::out_of_range& e) {
6606       {
6607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6608       };
6609     } catch (std::exception& e) {
6610       {
6611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6612       };
6613     } catch (Dali::DaliException e) {
6614       {
6615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6616       };
6617     } catch (...) {
6618       {
6619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6620       };
6621     }
6622   }
6623
6624   jresult = result;
6625   return jresult;
6626 }
6627
6628
6629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6630   void * jresult ;
6631   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6632   Dali::Vector3 *arg2 = 0 ;
6633   Dali::Vector3 result;
6634
6635   arg1 = (Dali::Vector3 *)jarg1;
6636   arg2 = (Dali::Vector3 *)jarg2;
6637   if (!arg2) {
6638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6639     return 0;
6640   }
6641   {
6642     try {
6643       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6644     } catch (std::out_of_range& e) {
6645       {
6646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6647       };
6648     } catch (std::exception& e) {
6649       {
6650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6651       };
6652     } catch (Dali::DaliException e) {
6653       {
6654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6655       };
6656     } catch (...) {
6657       {
6658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6659       };
6660     }
6661   }
6662
6663   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6664   return jresult;
6665 }
6666
6667
6668 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6669   float jresult ;
6670   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6671   float result;
6672
6673   arg1 = (Dali::Vector3 *)jarg1;
6674   {
6675     try {
6676       result = (float)((Dali::Vector3 const *)arg1)->Length();
6677     } catch (std::out_of_range& e) {
6678       {
6679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6680       };
6681     } catch (std::exception& e) {
6682       {
6683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6684       };
6685     } catch (Dali::DaliException e) {
6686       {
6687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6688       };
6689     } catch (...) {
6690       {
6691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6692       };
6693     }
6694   }
6695
6696   jresult = result;
6697   return jresult;
6698 }
6699
6700
6701 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6702   float jresult ;
6703   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6704   float result;
6705
6706   arg1 = (Dali::Vector3 *)jarg1;
6707   {
6708     try {
6709       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6710     } catch (std::out_of_range& e) {
6711       {
6712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6713       };
6714     } catch (std::exception& e) {
6715       {
6716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6717       };
6718     } catch (Dali::DaliException e) {
6719       {
6720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6721       };
6722     } catch (...) {
6723       {
6724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6725       };
6726     }
6727   }
6728
6729   jresult = result;
6730   return jresult;
6731 }
6732
6733
6734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6735   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6736
6737   arg1 = (Dali::Vector3 *)jarg1;
6738   {
6739     try {
6740       (arg1)->Normalize();
6741     } catch (std::out_of_range& e) {
6742       {
6743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6744       };
6745     } catch (std::exception& e) {
6746       {
6747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6748       };
6749     } catch (Dali::DaliException e) {
6750       {
6751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6752       };
6753     } catch (...) {
6754       {
6755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6756       };
6757     }
6758   }
6759
6760 }
6761
6762
6763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6764   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6765   Dali::Vector3 *arg2 = 0 ;
6766   Dali::Vector3 *arg3 = 0 ;
6767
6768   arg1 = (Dali::Vector3 *)jarg1;
6769   arg2 = (Dali::Vector3 *)jarg2;
6770   if (!arg2) {
6771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6772     return ;
6773   }
6774   arg3 = (Dali::Vector3 *)jarg3;
6775   if (!arg3) {
6776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6777     return ;
6778   }
6779   {
6780     try {
6781       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6782     } catch (std::out_of_range& e) {
6783       {
6784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6785       };
6786     } catch (std::exception& e) {
6787       {
6788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6789       };
6790     } catch (Dali::DaliException e) {
6791       {
6792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6793       };
6794     } catch (...) {
6795       {
6796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6797       };
6798     }
6799   }
6800
6801 }
6802
6803
6804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6805   void * jresult ;
6806   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6807   float *result = 0 ;
6808
6809   arg1 = (Dali::Vector3 *)jarg1;
6810   {
6811     try {
6812       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6813     } catch (std::out_of_range& e) {
6814       {
6815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6816       };
6817     } catch (std::exception& e) {
6818       {
6819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6820       };
6821     } catch (Dali::DaliException e) {
6822       {
6823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6824       };
6825     } catch (...) {
6826       {
6827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6828       };
6829     }
6830   }
6831
6832   jresult = (void *)result;
6833   return jresult;
6834 }
6835
6836
6837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6838   void * jresult ;
6839   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6840   Dali::Vector2 *result = 0 ;
6841
6842   arg1 = (Dali::Vector3 *)jarg1;
6843   {
6844     try {
6845       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6846     } catch (std::out_of_range& e) {
6847       {
6848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6849       };
6850     } catch (std::exception& e) {
6851       {
6852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6853       };
6854     } catch (Dali::DaliException e) {
6855       {
6856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6857       };
6858     } catch (...) {
6859       {
6860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6861       };
6862     }
6863   }
6864
6865   jresult = (void *)result;
6866   return jresult;
6867 }
6868
6869
6870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6871   void * jresult ;
6872   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6873   Dali::Vector2 *result = 0 ;
6874
6875   arg1 = (Dali::Vector3 *)jarg1;
6876   {
6877     try {
6878       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6879     } catch (std::out_of_range& e) {
6880       {
6881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6882       };
6883     } catch (std::exception& e) {
6884       {
6885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6886       };
6887     } catch (Dali::DaliException e) {
6888       {
6889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6890       };
6891     } catch (...) {
6892       {
6893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6894       };
6895     }
6896   }
6897
6898   jresult = (void *)result;
6899   return jresult;
6900 }
6901
6902
6903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6904   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6905   float arg2 ;
6906
6907   arg1 = (Dali::Vector3 *)jarg1;
6908   arg2 = (float)jarg2;
6909   if (arg1) (arg1)->x = arg2;
6910 }
6911
6912
6913 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6914   float jresult ;
6915   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6916   float result;
6917
6918   arg1 = (Dali::Vector3 *)jarg1;
6919   result = (float) ((arg1)->x);
6920   jresult = result;
6921   return jresult;
6922 }
6923
6924
6925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6926   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6927   float arg2 ;
6928
6929   arg1 = (Dali::Vector3 *)jarg1;
6930   arg2 = (float)jarg2;
6931   if (arg1) (arg1)->width = arg2;
6932 }
6933
6934
6935 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6936   float jresult ;
6937   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6938   float result;
6939
6940   arg1 = (Dali::Vector3 *)jarg1;
6941   result = (float) ((arg1)->width);
6942   jresult = result;
6943   return jresult;
6944 }
6945
6946
6947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6948   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6949   float arg2 ;
6950
6951   arg1 = (Dali::Vector3 *)jarg1;
6952   arg2 = (float)jarg2;
6953   if (arg1) (arg1)->r = arg2;
6954 }
6955
6956
6957 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6958   float jresult ;
6959   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6960   float result;
6961
6962   arg1 = (Dali::Vector3 *)jarg1;
6963   result = (float) ((arg1)->r);
6964   jresult = result;
6965   return jresult;
6966 }
6967
6968
6969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6970   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6971   float arg2 ;
6972
6973   arg1 = (Dali::Vector3 *)jarg1;
6974   arg2 = (float)jarg2;
6975   if (arg1) (arg1)->y = arg2;
6976 }
6977
6978
6979 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6980   float jresult ;
6981   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6982   float result;
6983
6984   arg1 = (Dali::Vector3 *)jarg1;
6985   result = (float) ((arg1)->y);
6986   jresult = result;
6987   return jresult;
6988 }
6989
6990
6991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6992   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6993   float arg2 ;
6994
6995   arg1 = (Dali::Vector3 *)jarg1;
6996   arg2 = (float)jarg2;
6997   if (arg1) (arg1)->height = arg2;
6998 }
6999
7000
7001 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7002   float jresult ;
7003   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7004   float result;
7005
7006   arg1 = (Dali::Vector3 *)jarg1;
7007   result = (float) ((arg1)->height);
7008   jresult = result;
7009   return jresult;
7010 }
7011
7012
7013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7014   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7015   float arg2 ;
7016
7017   arg1 = (Dali::Vector3 *)jarg1;
7018   arg2 = (float)jarg2;
7019   if (arg1) (arg1)->g = arg2;
7020 }
7021
7022
7023 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7024   float jresult ;
7025   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7026   float result;
7027
7028   arg1 = (Dali::Vector3 *)jarg1;
7029   result = (float) ((arg1)->g);
7030   jresult = result;
7031   return jresult;
7032 }
7033
7034
7035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7036   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7037   float arg2 ;
7038
7039   arg1 = (Dali::Vector3 *)jarg1;
7040   arg2 = (float)jarg2;
7041   if (arg1) (arg1)->z = arg2;
7042 }
7043
7044
7045 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7046   float jresult ;
7047   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7048   float result;
7049
7050   arg1 = (Dali::Vector3 *)jarg1;
7051   result = (float) ((arg1)->z);
7052   jresult = result;
7053   return jresult;
7054 }
7055
7056
7057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7058   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7059   float arg2 ;
7060
7061   arg1 = (Dali::Vector3 *)jarg1;
7062   arg2 = (float)jarg2;
7063   if (arg1) (arg1)->depth = arg2;
7064 }
7065
7066
7067 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7068   float jresult ;
7069   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7070   float result;
7071
7072   arg1 = (Dali::Vector3 *)jarg1;
7073   result = (float) ((arg1)->depth);
7074   jresult = result;
7075   return jresult;
7076 }
7077
7078
7079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7080   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7081   float arg2 ;
7082
7083   arg1 = (Dali::Vector3 *)jarg1;
7084   arg2 = (float)jarg2;
7085   if (arg1) (arg1)->b = arg2;
7086 }
7087
7088
7089 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7090   float jresult ;
7091   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7092   float result;
7093
7094   arg1 = (Dali::Vector3 *)jarg1;
7095   result = (float) ((arg1)->b);
7096   jresult = result;
7097   return jresult;
7098 }
7099
7100
7101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7102   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7103
7104   arg1 = (Dali::Vector3 *)jarg1;
7105   {
7106     try {
7107       delete arg1;
7108     } catch (std::out_of_range& e) {
7109       {
7110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7111       };
7112     } catch (std::exception& e) {
7113       {
7114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7115       };
7116     } catch (Dali::DaliException e) {
7117       {
7118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7119       };
7120     } catch (...) {
7121       {
7122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7123       };
7124     }
7125   }
7126
7127 }
7128
7129
7130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7131   void * jresult ;
7132   Dali::Vector3 *arg1 = 0 ;
7133   Dali::Vector3 *arg2 = 0 ;
7134   Dali::Vector3 result;
7135
7136   arg1 = (Dali::Vector3 *)jarg1;
7137   if (!arg1) {
7138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7139     return 0;
7140   }
7141   arg2 = (Dali::Vector3 *)jarg2;
7142   if (!arg2) {
7143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7144     return 0;
7145   }
7146   {
7147     try {
7148       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7149     } catch (std::out_of_range& e) {
7150       {
7151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7152       };
7153     } catch (std::exception& e) {
7154       {
7155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7156       };
7157     } catch (Dali::DaliException e) {
7158       {
7159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7160       };
7161     } catch (...) {
7162       {
7163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7164       };
7165     }
7166   }
7167
7168   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7169   return jresult;
7170 }
7171
7172
7173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7174   void * jresult ;
7175   Dali::Vector3 *arg1 = 0 ;
7176   Dali::Vector3 *arg2 = 0 ;
7177   Dali::Vector3 result;
7178
7179   arg1 = (Dali::Vector3 *)jarg1;
7180   if (!arg1) {
7181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7182     return 0;
7183   }
7184   arg2 = (Dali::Vector3 *)jarg2;
7185   if (!arg2) {
7186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7187     return 0;
7188   }
7189   {
7190     try {
7191       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7192     } catch (std::out_of_range& e) {
7193       {
7194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7195       };
7196     } catch (std::exception& e) {
7197       {
7198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7199       };
7200     } catch (Dali::DaliException e) {
7201       {
7202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7203       };
7204     } catch (...) {
7205       {
7206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7207       };
7208     }
7209   }
7210
7211   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7212   return jresult;
7213 }
7214
7215
7216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7217   void * jresult ;
7218   Dali::Vector3 *arg1 = 0 ;
7219   float *arg2 = 0 ;
7220   float *arg3 = 0 ;
7221   float temp2 ;
7222   float temp3 ;
7223   Dali::Vector3 result;
7224
7225   arg1 = (Dali::Vector3 *)jarg1;
7226   if (!arg1) {
7227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7228     return 0;
7229   }
7230   temp2 = (float)jarg2;
7231   arg2 = &temp2;
7232   temp3 = (float)jarg3;
7233   arg3 = &temp3;
7234   {
7235     try {
7236       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7237     } catch (std::out_of_range& e) {
7238       {
7239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7240       };
7241     } catch (std::exception& e) {
7242       {
7243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7244       };
7245     } catch (Dali::DaliException e) {
7246       {
7247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7248       };
7249     } catch (...) {
7250       {
7251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7252       };
7253     }
7254   }
7255
7256   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7257   return jresult;
7258 }
7259
7260
7261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7262   void * jresult ;
7263   Dali::Vector4 *result = 0 ;
7264
7265   {
7266     try {
7267       result = (Dali::Vector4 *)new Dali::Vector4();
7268     } catch (std::out_of_range& e) {
7269       {
7270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7271       };
7272     } catch (std::exception& e) {
7273       {
7274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7275       };
7276     } catch (Dali::DaliException e) {
7277       {
7278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7279       };
7280     } catch (...) {
7281       {
7282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7283       };
7284     }
7285   }
7286
7287   jresult = (void *)result;
7288   return jresult;
7289 }
7290
7291
7292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7293   void * jresult ;
7294   float arg1 ;
7295   float arg2 ;
7296   float arg3 ;
7297   float arg4 ;
7298   Dali::Vector4 *result = 0 ;
7299
7300   arg1 = (float)jarg1;
7301   arg2 = (float)jarg2;
7302   arg3 = (float)jarg3;
7303   arg4 = (float)jarg4;
7304   {
7305     try {
7306       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7307     } catch (std::out_of_range& e) {
7308       {
7309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7310       };
7311     } catch (std::exception& e) {
7312       {
7313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7314       };
7315     } catch (Dali::DaliException e) {
7316       {
7317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7318       };
7319     } catch (...) {
7320       {
7321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7322       };
7323     }
7324   }
7325
7326   jresult = (void *)result;
7327   return jresult;
7328 }
7329
7330
7331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7332   void * jresult ;
7333   float *arg1 = (float *) 0 ;
7334   Dali::Vector4 *result = 0 ;
7335
7336   arg1 = jarg1;
7337   {
7338     try {
7339       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7340     } catch (std::out_of_range& e) {
7341       {
7342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7343       };
7344     } catch (std::exception& e) {
7345       {
7346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7347       };
7348     } catch (Dali::DaliException e) {
7349       {
7350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7351       };
7352     } catch (...) {
7353       {
7354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7355       };
7356     }
7357   }
7358
7359   jresult = (void *)result;
7360
7361
7362   return jresult;
7363 }
7364
7365
7366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7367   void * jresult ;
7368   Dali::Vector2 *arg1 = 0 ;
7369   Dali::Vector4 *result = 0 ;
7370
7371   arg1 = (Dali::Vector2 *)jarg1;
7372   if (!arg1) {
7373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7374     return 0;
7375   }
7376   {
7377     try {
7378       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7379     } catch (std::out_of_range& e) {
7380       {
7381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7382       };
7383     } catch (std::exception& e) {
7384       {
7385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7386       };
7387     } catch (Dali::DaliException e) {
7388       {
7389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7390       };
7391     } catch (...) {
7392       {
7393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7394       };
7395     }
7396   }
7397
7398   jresult = (void *)result;
7399   return jresult;
7400 }
7401
7402
7403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7404   void * jresult ;
7405   Dali::Vector3 *arg1 = 0 ;
7406   Dali::Vector4 *result = 0 ;
7407
7408   arg1 = (Dali::Vector3 *)jarg1;
7409   if (!arg1) {
7410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7411     return 0;
7412   }
7413   {
7414     try {
7415       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7416     } catch (std::out_of_range& e) {
7417       {
7418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7419       };
7420     } catch (std::exception& e) {
7421       {
7422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7423       };
7424     } catch (Dali::DaliException e) {
7425       {
7426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7427       };
7428     } catch (...) {
7429       {
7430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7431       };
7432     }
7433   }
7434
7435   jresult = (void *)result;
7436   return jresult;
7437 }
7438
7439
7440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7441   void * jresult ;
7442   Dali::Vector4 *result = 0 ;
7443
7444   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7445   jresult = (void *)result;
7446   return jresult;
7447 }
7448
7449
7450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7451   void * jresult ;
7452   Dali::Vector4 *result = 0 ;
7453
7454   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7455   jresult = (void *)result;
7456   return jresult;
7457 }
7458
7459
7460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7461   void * jresult ;
7462   Dali::Vector4 *result = 0 ;
7463
7464   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7465   jresult = (void *)result;
7466   return jresult;
7467 }
7468
7469
7470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7471   void * jresult ;
7472   Dali::Vector4 *result = 0 ;
7473
7474   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7475   jresult = (void *)result;
7476   return jresult;
7477 }
7478
7479
7480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7481   void * jresult ;
7482   Dali::Vector4 *result = 0 ;
7483
7484   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7485   jresult = (void *)result;
7486   return jresult;
7487 }
7488
7489
7490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7491   void * jresult ;
7492   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7493   float *arg2 = (float *) 0 ;
7494   Dali::Vector4 *result = 0 ;
7495
7496   arg1 = (Dali::Vector4 *)jarg1;
7497   arg2 = jarg2;
7498   {
7499     try {
7500       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7501     } catch (std::out_of_range& e) {
7502       {
7503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7504       };
7505     } catch (std::exception& e) {
7506       {
7507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7508       };
7509     } catch (Dali::DaliException e) {
7510       {
7511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7512       };
7513     } catch (...) {
7514       {
7515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7516       };
7517     }
7518   }
7519
7520   jresult = (void *)result;
7521
7522
7523   return jresult;
7524 }
7525
7526
7527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7528   void * jresult ;
7529   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7530   Dali::Vector2 *arg2 = 0 ;
7531   Dali::Vector4 *result = 0 ;
7532
7533   arg1 = (Dali::Vector4 *)jarg1;
7534   arg2 = (Dali::Vector2 *)jarg2;
7535   if (!arg2) {
7536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7537     return 0;
7538   }
7539   {
7540     try {
7541       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7542     } catch (std::out_of_range& e) {
7543       {
7544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7545       };
7546     } catch (std::exception& e) {
7547       {
7548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7549       };
7550     } catch (Dali::DaliException e) {
7551       {
7552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7553       };
7554     } catch (...) {
7555       {
7556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7557       };
7558     }
7559   }
7560
7561   jresult = (void *)result;
7562   return jresult;
7563 }
7564
7565
7566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7567   void * jresult ;
7568   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7569   Dali::Vector3 *arg2 = 0 ;
7570   Dali::Vector4 *result = 0 ;
7571
7572   arg1 = (Dali::Vector4 *)jarg1;
7573   arg2 = (Dali::Vector3 *)jarg2;
7574   if (!arg2) {
7575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7576     return 0;
7577   }
7578   {
7579     try {
7580       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7581     } catch (std::out_of_range& e) {
7582       {
7583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7584       };
7585     } catch (std::exception& e) {
7586       {
7587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7588       };
7589     } catch (Dali::DaliException e) {
7590       {
7591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7592       };
7593     } catch (...) {
7594       {
7595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7596       };
7597     }
7598   }
7599
7600   jresult = (void *)result;
7601   return jresult;
7602 }
7603
7604
7605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7606   void * jresult ;
7607   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7608   Dali::Vector4 *arg2 = 0 ;
7609   Dali::Vector4 result;
7610
7611   arg1 = (Dali::Vector4 *)jarg1;
7612   arg2 = (Dali::Vector4 *)jarg2;
7613   if (!arg2) {
7614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7615     return 0;
7616   }
7617   {
7618     try {
7619       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7620     } catch (std::out_of_range& e) {
7621       {
7622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7623       };
7624     } catch (std::exception& e) {
7625       {
7626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7627       };
7628     } catch (Dali::DaliException e) {
7629       {
7630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7631       };
7632     } catch (...) {
7633       {
7634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7635       };
7636     }
7637   }
7638
7639   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7640   return jresult;
7641 }
7642
7643
7644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7645   void * jresult ;
7646   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7647   Dali::Vector4 *arg2 = 0 ;
7648   Dali::Vector4 *result = 0 ;
7649
7650   arg1 = (Dali::Vector4 *)jarg1;
7651   arg2 = (Dali::Vector4 *)jarg2;
7652   if (!arg2) {
7653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7654     return 0;
7655   }
7656   {
7657     try {
7658       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7659     } catch (std::out_of_range& e) {
7660       {
7661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7662       };
7663     } catch (std::exception& e) {
7664       {
7665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7666       };
7667     } catch (Dali::DaliException e) {
7668       {
7669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7670       };
7671     } catch (...) {
7672       {
7673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7674       };
7675     }
7676   }
7677
7678   jresult = (void *)result;
7679   return jresult;
7680 }
7681
7682
7683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7684   void * jresult ;
7685   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7686   Dali::Vector4 *arg2 = 0 ;
7687   Dali::Vector4 result;
7688
7689   arg1 = (Dali::Vector4 *)jarg1;
7690   arg2 = (Dali::Vector4 *)jarg2;
7691   if (!arg2) {
7692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7693     return 0;
7694   }
7695   {
7696     try {
7697       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7698     } catch (std::out_of_range& e) {
7699       {
7700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7701       };
7702     } catch (std::exception& e) {
7703       {
7704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7705       };
7706     } catch (Dali::DaliException e) {
7707       {
7708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7709       };
7710     } catch (...) {
7711       {
7712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7713       };
7714     }
7715   }
7716
7717   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7718   return jresult;
7719 }
7720
7721
7722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7723   void * jresult ;
7724   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7725   Dali::Vector4 *arg2 = 0 ;
7726   Dali::Vector4 *result = 0 ;
7727
7728   arg1 = (Dali::Vector4 *)jarg1;
7729   arg2 = (Dali::Vector4 *)jarg2;
7730   if (!arg2) {
7731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7732     return 0;
7733   }
7734   {
7735     try {
7736       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7737     } catch (std::out_of_range& e) {
7738       {
7739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7740       };
7741     } catch (std::exception& e) {
7742       {
7743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7744       };
7745     } catch (Dali::DaliException e) {
7746       {
7747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7748       };
7749     } catch (...) {
7750       {
7751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7752       };
7753     }
7754   }
7755
7756   jresult = (void *)result;
7757   return jresult;
7758 }
7759
7760
7761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7762   void * jresult ;
7763   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7764   Dali::Vector4 *arg2 = 0 ;
7765   Dali::Vector4 result;
7766
7767   arg1 = (Dali::Vector4 *)jarg1;
7768   arg2 = (Dali::Vector4 *)jarg2;
7769   if (!arg2) {
7770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7771     return 0;
7772   }
7773   {
7774     try {
7775       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7776     } catch (std::out_of_range& e) {
7777       {
7778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7779       };
7780     } catch (std::exception& e) {
7781       {
7782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7783       };
7784     } catch (Dali::DaliException e) {
7785       {
7786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7787       };
7788     } catch (...) {
7789       {
7790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7791       };
7792     }
7793   }
7794
7795   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7796   return jresult;
7797 }
7798
7799
7800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7801   void * jresult ;
7802   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7803   float arg2 ;
7804   Dali::Vector4 result;
7805
7806   arg1 = (Dali::Vector4 *)jarg1;
7807   arg2 = (float)jarg2;
7808   {
7809     try {
7810       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7811     } catch (std::out_of_range& e) {
7812       {
7813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7814       };
7815     } catch (std::exception& e) {
7816       {
7817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7818       };
7819     } catch (Dali::DaliException e) {
7820       {
7821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7822       };
7823     } catch (...) {
7824       {
7825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7826       };
7827     }
7828   }
7829
7830   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7831   return jresult;
7832 }
7833
7834
7835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7836   void * jresult ;
7837   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7838   Dali::Vector4 *arg2 = 0 ;
7839   Dali::Vector4 *result = 0 ;
7840
7841   arg1 = (Dali::Vector4 *)jarg1;
7842   arg2 = (Dali::Vector4 *)jarg2;
7843   if (!arg2) {
7844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7845     return 0;
7846   }
7847   {
7848     try {
7849       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7850     } catch (std::out_of_range& e) {
7851       {
7852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7853       };
7854     } catch (std::exception& e) {
7855       {
7856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7857       };
7858     } catch (Dali::DaliException e) {
7859       {
7860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7861       };
7862     } catch (...) {
7863       {
7864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7865       };
7866     }
7867   }
7868
7869   jresult = (void *)result;
7870   return jresult;
7871 }
7872
7873
7874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7875   void * jresult ;
7876   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7877   float arg2 ;
7878   Dali::Vector4 *result = 0 ;
7879
7880   arg1 = (Dali::Vector4 *)jarg1;
7881   arg2 = (float)jarg2;
7882   {
7883     try {
7884       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7885     } catch (std::out_of_range& e) {
7886       {
7887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7888       };
7889     } catch (std::exception& e) {
7890       {
7891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7892       };
7893     } catch (Dali::DaliException e) {
7894       {
7895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7896       };
7897     } catch (...) {
7898       {
7899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7900       };
7901     }
7902   }
7903
7904   jresult = (void *)result;
7905   return jresult;
7906 }
7907
7908
7909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7910   void * jresult ;
7911   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7912   Dali::Vector4 *arg2 = 0 ;
7913   Dali::Vector4 result;
7914
7915   arg1 = (Dali::Vector4 *)jarg1;
7916   arg2 = (Dali::Vector4 *)jarg2;
7917   if (!arg2) {
7918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7919     return 0;
7920   }
7921   {
7922     try {
7923       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7924     } catch (std::out_of_range& e) {
7925       {
7926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7927       };
7928     } catch (std::exception& e) {
7929       {
7930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7931       };
7932     } catch (Dali::DaliException e) {
7933       {
7934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7935       };
7936     } catch (...) {
7937       {
7938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7939       };
7940     }
7941   }
7942
7943   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7944   return jresult;
7945 }
7946
7947
7948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7949   void * jresult ;
7950   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7951   float arg2 ;
7952   Dali::Vector4 result;
7953
7954   arg1 = (Dali::Vector4 *)jarg1;
7955   arg2 = (float)jarg2;
7956   {
7957     try {
7958       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7959     } catch (std::out_of_range& e) {
7960       {
7961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7962       };
7963     } catch (std::exception& e) {
7964       {
7965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7966       };
7967     } catch (Dali::DaliException e) {
7968       {
7969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7970       };
7971     } catch (...) {
7972       {
7973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7974       };
7975     }
7976   }
7977
7978   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7979   return jresult;
7980 }
7981
7982
7983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7984   void * jresult ;
7985   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7986   Dali::Vector4 *arg2 = 0 ;
7987   Dali::Vector4 *result = 0 ;
7988
7989   arg1 = (Dali::Vector4 *)jarg1;
7990   arg2 = (Dali::Vector4 *)jarg2;
7991   if (!arg2) {
7992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7993     return 0;
7994   }
7995   {
7996     try {
7997       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7998     } catch (std::out_of_range& e) {
7999       {
8000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8001       };
8002     } catch (std::exception& e) {
8003       {
8004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8005       };
8006     } catch (Dali::DaliException e) {
8007       {
8008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8009       };
8010     } catch (...) {
8011       {
8012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8013       };
8014     }
8015   }
8016
8017   jresult = (void *)result;
8018   return jresult;
8019 }
8020
8021
8022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8023   void * jresult ;
8024   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8025   float arg2 ;
8026   Dali::Vector4 *result = 0 ;
8027
8028   arg1 = (Dali::Vector4 *)jarg1;
8029   arg2 = (float)jarg2;
8030   {
8031     try {
8032       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8033     } catch (std::out_of_range& e) {
8034       {
8035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8036       };
8037     } catch (std::exception& e) {
8038       {
8039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8040       };
8041     } catch (Dali::DaliException e) {
8042       {
8043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8044       };
8045     } catch (...) {
8046       {
8047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8048       };
8049     }
8050   }
8051
8052   jresult = (void *)result;
8053   return jresult;
8054 }
8055
8056
8057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8058   void * jresult ;
8059   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8060   Dali::Vector4 result;
8061
8062   arg1 = (Dali::Vector4 *)jarg1;
8063   {
8064     try {
8065       result = ((Dali::Vector4 const *)arg1)->operator -();
8066     } catch (std::out_of_range& e) {
8067       {
8068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8069       };
8070     } catch (std::exception& e) {
8071       {
8072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8073       };
8074     } catch (Dali::DaliException e) {
8075       {
8076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8077       };
8078     } catch (...) {
8079       {
8080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8081       };
8082     }
8083   }
8084
8085   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8086   return jresult;
8087 }
8088
8089
8090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8091   unsigned int jresult ;
8092   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8093   Dali::Vector4 *arg2 = 0 ;
8094   bool result;
8095
8096   arg1 = (Dali::Vector4 *)jarg1;
8097   arg2 = (Dali::Vector4 *)jarg2;
8098   if (!arg2) {
8099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8100     return 0;
8101   }
8102   {
8103     try {
8104       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8105     } catch (std::out_of_range& e) {
8106       {
8107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8108       };
8109     } catch (std::exception& e) {
8110       {
8111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8112       };
8113     } catch (Dali::DaliException e) {
8114       {
8115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8116       };
8117     } catch (...) {
8118       {
8119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8120       };
8121     }
8122   }
8123
8124   jresult = result;
8125   return jresult;
8126 }
8127
8128
8129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8130   unsigned int jresult ;
8131   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8132   Dali::Vector4 *arg2 = 0 ;
8133   bool result;
8134
8135   arg1 = (Dali::Vector4 *)jarg1;
8136   arg2 = (Dali::Vector4 *)jarg2;
8137   if (!arg2) {
8138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8139     return 0;
8140   }
8141   {
8142     try {
8143       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8144     } catch (std::out_of_range& e) {
8145       {
8146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8147       };
8148     } catch (std::exception& e) {
8149       {
8150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8151       };
8152     } catch (Dali::DaliException e) {
8153       {
8154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8155       };
8156     } catch (...) {
8157       {
8158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8159       };
8160     }
8161   }
8162
8163   jresult = result;
8164   return jresult;
8165 }
8166
8167
8168 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8169   float jresult ;
8170   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8171   unsigned int arg2 ;
8172   float *result = 0 ;
8173
8174   arg1 = (Dali::Vector4 *)jarg1;
8175   arg2 = (unsigned int)jarg2;
8176   {
8177     try {
8178       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8179     } catch (std::out_of_range& e) {
8180       {
8181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8182       };
8183     } catch (std::exception& e) {
8184       {
8185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8186       };
8187     } catch (Dali::DaliException e) {
8188       {
8189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8190       };
8191     } catch (...) {
8192       {
8193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8194       };
8195     }
8196   }
8197
8198   jresult = *result;
8199   return jresult;
8200 }
8201
8202
8203 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8204   float jresult ;
8205   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8206   Dali::Vector3 *arg2 = 0 ;
8207   float result;
8208
8209   arg1 = (Dali::Vector4 *)jarg1;
8210   arg2 = (Dali::Vector3 *)jarg2;
8211   if (!arg2) {
8212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8213     return 0;
8214   }
8215   {
8216     try {
8217       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8218     } catch (std::out_of_range& e) {
8219       {
8220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8221       };
8222     } catch (std::exception& e) {
8223       {
8224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8225       };
8226     } catch (Dali::DaliException e) {
8227       {
8228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8229       };
8230     } catch (...) {
8231       {
8232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8233       };
8234     }
8235   }
8236
8237   jresult = result;
8238   return jresult;
8239 }
8240
8241
8242 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8243   float jresult ;
8244   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8245   Dali::Vector4 *arg2 = 0 ;
8246   float result;
8247
8248   arg1 = (Dali::Vector4 *)jarg1;
8249   arg2 = (Dali::Vector4 *)jarg2;
8250   if (!arg2) {
8251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8252     return 0;
8253   }
8254   {
8255     try {
8256       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8257     } catch (std::out_of_range& e) {
8258       {
8259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8260       };
8261     } catch (std::exception& e) {
8262       {
8263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8264       };
8265     } catch (Dali::DaliException e) {
8266       {
8267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8268       };
8269     } catch (...) {
8270       {
8271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8272       };
8273     }
8274   }
8275
8276   jresult = result;
8277   return jresult;
8278 }
8279
8280
8281 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8282   float jresult ;
8283   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8284   Dali::Vector4 *arg2 = 0 ;
8285   float result;
8286
8287   arg1 = (Dali::Vector4 *)jarg1;
8288   arg2 = (Dali::Vector4 *)jarg2;
8289   if (!arg2) {
8290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8291     return 0;
8292   }
8293   {
8294     try {
8295       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8296     } catch (std::out_of_range& e) {
8297       {
8298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8299       };
8300     } catch (std::exception& e) {
8301       {
8302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8303       };
8304     } catch (Dali::DaliException e) {
8305       {
8306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8307       };
8308     } catch (...) {
8309       {
8310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8311       };
8312     }
8313   }
8314
8315   jresult = result;
8316   return jresult;
8317 }
8318
8319
8320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8321   void * jresult ;
8322   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8323   Dali::Vector4 *arg2 = 0 ;
8324   Dali::Vector4 result;
8325
8326   arg1 = (Dali::Vector4 *)jarg1;
8327   arg2 = (Dali::Vector4 *)jarg2;
8328   if (!arg2) {
8329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8330     return 0;
8331   }
8332   {
8333     try {
8334       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8335     } catch (std::out_of_range& e) {
8336       {
8337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8338       };
8339     } catch (std::exception& e) {
8340       {
8341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8342       };
8343     } catch (Dali::DaliException e) {
8344       {
8345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8346       };
8347     } catch (...) {
8348       {
8349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8350       };
8351     }
8352   }
8353
8354   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8355   return jresult;
8356 }
8357
8358
8359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8360   float jresult ;
8361   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8362   float result;
8363
8364   arg1 = (Dali::Vector4 *)jarg1;
8365   {
8366     try {
8367       result = (float)((Dali::Vector4 const *)arg1)->Length();
8368     } catch (std::out_of_range& e) {
8369       {
8370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8371       };
8372     } catch (std::exception& e) {
8373       {
8374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8375       };
8376     } catch (Dali::DaliException e) {
8377       {
8378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8379       };
8380     } catch (...) {
8381       {
8382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8383       };
8384     }
8385   }
8386
8387   jresult = result;
8388   return jresult;
8389 }
8390
8391
8392 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8393   float jresult ;
8394   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8395   float result;
8396
8397   arg1 = (Dali::Vector4 *)jarg1;
8398   {
8399     try {
8400       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8401     } catch (std::out_of_range& e) {
8402       {
8403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8404       };
8405     } catch (std::exception& e) {
8406       {
8407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8408       };
8409     } catch (Dali::DaliException e) {
8410       {
8411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8412       };
8413     } catch (...) {
8414       {
8415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8416       };
8417     }
8418   }
8419
8420   jresult = result;
8421   return jresult;
8422 }
8423
8424
8425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8426   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8427
8428   arg1 = (Dali::Vector4 *)jarg1;
8429   {
8430     try {
8431       (arg1)->Normalize();
8432     } catch (std::out_of_range& e) {
8433       {
8434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8435       };
8436     } catch (std::exception& e) {
8437       {
8438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8439       };
8440     } catch (Dali::DaliException e) {
8441       {
8442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8443       };
8444     } catch (...) {
8445       {
8446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8447       };
8448     }
8449   }
8450
8451 }
8452
8453
8454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8455   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8456   Dali::Vector4 *arg2 = 0 ;
8457   Dali::Vector4 *arg3 = 0 ;
8458
8459   arg1 = (Dali::Vector4 *)jarg1;
8460   arg2 = (Dali::Vector4 *)jarg2;
8461   if (!arg2) {
8462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8463     return ;
8464   }
8465   arg3 = (Dali::Vector4 *)jarg3;
8466   if (!arg3) {
8467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8468     return ;
8469   }
8470   {
8471     try {
8472       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8473     } catch (std::out_of_range& e) {
8474       {
8475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8476       };
8477     } catch (std::exception& e) {
8478       {
8479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8480       };
8481     } catch (Dali::DaliException e) {
8482       {
8483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8484       };
8485     } catch (...) {
8486       {
8487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8488       };
8489     }
8490   }
8491
8492 }
8493
8494
8495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8496   void * jresult ;
8497   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8498   float *result = 0 ;
8499
8500   arg1 = (Dali::Vector4 *)jarg1;
8501   {
8502     try {
8503       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8504     } catch (std::out_of_range& e) {
8505       {
8506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8507       };
8508     } catch (std::exception& e) {
8509       {
8510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8511       };
8512     } catch (Dali::DaliException e) {
8513       {
8514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8515       };
8516     } catch (...) {
8517       {
8518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8519       };
8520     }
8521   }
8522
8523   jresult = (void *)result;
8524   return jresult;
8525 }
8526
8527
8528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8529   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8530   float arg2 ;
8531
8532   arg1 = (Dali::Vector4 *)jarg1;
8533   arg2 = (float)jarg2;
8534   if (arg1) (arg1)->x = arg2;
8535 }
8536
8537
8538 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8539   float jresult ;
8540   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8541   float result;
8542
8543   arg1 = (Dali::Vector4 *)jarg1;
8544   result = (float) ((arg1)->x);
8545   jresult = result;
8546   return jresult;
8547 }
8548
8549
8550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8551   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8552   float arg2 ;
8553
8554   arg1 = (Dali::Vector4 *)jarg1;
8555   arg2 = (float)jarg2;
8556   if (arg1) (arg1)->r = arg2;
8557 }
8558
8559
8560 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8561   float jresult ;
8562   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8563   float result;
8564
8565   arg1 = (Dali::Vector4 *)jarg1;
8566   result = (float) ((arg1)->r);
8567   jresult = result;
8568   return jresult;
8569 }
8570
8571
8572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8573   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8574   float arg2 ;
8575
8576   arg1 = (Dali::Vector4 *)jarg1;
8577   arg2 = (float)jarg2;
8578   if (arg1) (arg1)->s = arg2;
8579 }
8580
8581
8582 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8583   float jresult ;
8584   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8585   float result;
8586
8587   arg1 = (Dali::Vector4 *)jarg1;
8588   result = (float) ((arg1)->s);
8589   jresult = result;
8590   return jresult;
8591 }
8592
8593
8594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8595   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8596   float arg2 ;
8597
8598   arg1 = (Dali::Vector4 *)jarg1;
8599   arg2 = (float)jarg2;
8600   if (arg1) (arg1)->y = arg2;
8601 }
8602
8603
8604 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8605   float jresult ;
8606   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8607   float result;
8608
8609   arg1 = (Dali::Vector4 *)jarg1;
8610   result = (float) ((arg1)->y);
8611   jresult = result;
8612   return jresult;
8613 }
8614
8615
8616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8617   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8618   float arg2 ;
8619
8620   arg1 = (Dali::Vector4 *)jarg1;
8621   arg2 = (float)jarg2;
8622   if (arg1) (arg1)->g = arg2;
8623 }
8624
8625
8626 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8627   float jresult ;
8628   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8629   float result;
8630
8631   arg1 = (Dali::Vector4 *)jarg1;
8632   result = (float) ((arg1)->g);
8633   jresult = result;
8634   return jresult;
8635 }
8636
8637
8638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8639   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8640   float arg2 ;
8641
8642   arg1 = (Dali::Vector4 *)jarg1;
8643   arg2 = (float)jarg2;
8644   if (arg1) (arg1)->t = arg2;
8645 }
8646
8647
8648 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8649   float jresult ;
8650   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8651   float result;
8652
8653   arg1 = (Dali::Vector4 *)jarg1;
8654   result = (float) ((arg1)->t);
8655   jresult = result;
8656   return jresult;
8657 }
8658
8659
8660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8661   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8662   float arg2 ;
8663
8664   arg1 = (Dali::Vector4 *)jarg1;
8665   arg2 = (float)jarg2;
8666   if (arg1) (arg1)->z = arg2;
8667 }
8668
8669
8670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8671   float jresult ;
8672   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8673   float result;
8674
8675   arg1 = (Dali::Vector4 *)jarg1;
8676   result = (float) ((arg1)->z);
8677   jresult = result;
8678   return jresult;
8679 }
8680
8681
8682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8683   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8684   float arg2 ;
8685
8686   arg1 = (Dali::Vector4 *)jarg1;
8687   arg2 = (float)jarg2;
8688   if (arg1) (arg1)->b = arg2;
8689 }
8690
8691
8692 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8693   float jresult ;
8694   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8695   float result;
8696
8697   arg1 = (Dali::Vector4 *)jarg1;
8698   result = (float) ((arg1)->b);
8699   jresult = result;
8700   return jresult;
8701 }
8702
8703
8704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8705   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8706   float arg2 ;
8707
8708   arg1 = (Dali::Vector4 *)jarg1;
8709   arg2 = (float)jarg2;
8710   if (arg1) (arg1)->p = arg2;
8711 }
8712
8713
8714 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8715   float jresult ;
8716   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8717   float result;
8718
8719   arg1 = (Dali::Vector4 *)jarg1;
8720   result = (float) ((arg1)->p);
8721   jresult = result;
8722   return jresult;
8723 }
8724
8725
8726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8727   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8728   float arg2 ;
8729
8730   arg1 = (Dali::Vector4 *)jarg1;
8731   arg2 = (float)jarg2;
8732   if (arg1) (arg1)->w = arg2;
8733 }
8734
8735
8736 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8737   float jresult ;
8738   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8739   float result;
8740
8741   arg1 = (Dali::Vector4 *)jarg1;
8742   result = (float) ((arg1)->w);
8743   jresult = result;
8744   return jresult;
8745 }
8746
8747
8748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8749   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8750   float arg2 ;
8751
8752   arg1 = (Dali::Vector4 *)jarg1;
8753   arg2 = (float)jarg2;
8754   if (arg1) (arg1)->a = arg2;
8755 }
8756
8757
8758 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8759   float jresult ;
8760   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8761   float result;
8762
8763   arg1 = (Dali::Vector4 *)jarg1;
8764   result = (float) ((arg1)->a);
8765   jresult = result;
8766   return jresult;
8767 }
8768
8769
8770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8771   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8772   float arg2 ;
8773
8774   arg1 = (Dali::Vector4 *)jarg1;
8775   arg2 = (float)jarg2;
8776   if (arg1) (arg1)->q = arg2;
8777 }
8778
8779
8780 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8781   float jresult ;
8782   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8783   float result;
8784
8785   arg1 = (Dali::Vector4 *)jarg1;
8786   result = (float) ((arg1)->q);
8787   jresult = result;
8788   return jresult;
8789 }
8790
8791
8792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8793   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8794
8795   arg1 = (Dali::Vector4 *)jarg1;
8796   {
8797     try {
8798       delete arg1;
8799     } catch (std::out_of_range& e) {
8800       {
8801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8802       };
8803     } catch (std::exception& e) {
8804       {
8805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8806       };
8807     } catch (Dali::DaliException e) {
8808       {
8809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8810       };
8811     } catch (...) {
8812       {
8813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8814       };
8815     }
8816   }
8817
8818 }
8819
8820
8821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8822   void * jresult ;
8823   Dali::Vector4 *arg1 = 0 ;
8824   Dali::Vector4 *arg2 = 0 ;
8825   Dali::Vector4 result;
8826
8827   arg1 = (Dali::Vector4 *)jarg1;
8828   if (!arg1) {
8829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8830     return 0;
8831   }
8832   arg2 = (Dali::Vector4 *)jarg2;
8833   if (!arg2) {
8834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8835     return 0;
8836   }
8837   {
8838     try {
8839       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8840     } catch (std::out_of_range& e) {
8841       {
8842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8843       };
8844     } catch (std::exception& e) {
8845       {
8846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8847       };
8848     } catch (Dali::DaliException e) {
8849       {
8850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8851       };
8852     } catch (...) {
8853       {
8854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8855       };
8856     }
8857   }
8858
8859   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8860   return jresult;
8861 }
8862
8863
8864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8865   void * jresult ;
8866   Dali::Vector4 *arg1 = 0 ;
8867   Dali::Vector4 *arg2 = 0 ;
8868   Dali::Vector4 result;
8869
8870   arg1 = (Dali::Vector4 *)jarg1;
8871   if (!arg1) {
8872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8873     return 0;
8874   }
8875   arg2 = (Dali::Vector4 *)jarg2;
8876   if (!arg2) {
8877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8878     return 0;
8879   }
8880   {
8881     try {
8882       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8883     } catch (std::out_of_range& e) {
8884       {
8885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8886       };
8887     } catch (std::exception& e) {
8888       {
8889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8890       };
8891     } catch (Dali::DaliException e) {
8892       {
8893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8894       };
8895     } catch (...) {
8896       {
8897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8898       };
8899     }
8900   }
8901
8902   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8903   return jresult;
8904 }
8905
8906
8907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8908   void * jresult ;
8909   Dali::Vector4 *arg1 = 0 ;
8910   float *arg2 = 0 ;
8911   float *arg3 = 0 ;
8912   float temp2 ;
8913   float temp3 ;
8914   Dali::Vector4 result;
8915
8916   arg1 = (Dali::Vector4 *)jarg1;
8917   if (!arg1) {
8918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8919     return 0;
8920   }
8921   temp2 = (float)jarg2;
8922   arg2 = &temp2;
8923   temp3 = (float)jarg3;
8924   arg3 = &temp3;
8925   {
8926     try {
8927       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8928     } catch (std::out_of_range& e) {
8929       {
8930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8931       };
8932     } catch (std::exception& e) {
8933       {
8934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8935       };
8936     } catch (Dali::DaliException e) {
8937       {
8938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8939       };
8940     } catch (...) {
8941       {
8942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8943       };
8944     }
8945   }
8946
8947   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8948   return jresult;
8949 }
8950
8951
8952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8953   void * jresult ;
8954   Dali::Uint16Pair *result = 0 ;
8955
8956   {
8957     try {
8958       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8959     } catch (std::out_of_range& e) {
8960       {
8961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8962       };
8963     } catch (std::exception& e) {
8964       {
8965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8966       };
8967     } catch (Dali::DaliException e) {
8968       {
8969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8970       };
8971     } catch (...) {
8972       {
8973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8974       };
8975     }
8976   }
8977
8978   jresult = (void *)result;
8979   return jresult;
8980 }
8981
8982
8983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8984   void * jresult ;
8985   uint32_t arg1 ;
8986   uint32_t arg2 ;
8987   Dali::Uint16Pair *result = 0 ;
8988
8989   arg1 = (uint32_t)jarg1;
8990   arg2 = (uint32_t)jarg2;
8991   {
8992     try {
8993       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8994     } catch (std::out_of_range& e) {
8995       {
8996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8997       };
8998     } catch (std::exception& e) {
8999       {
9000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9001       };
9002     } catch (Dali::DaliException e) {
9003       {
9004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9005       };
9006     } catch (...) {
9007       {
9008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9009       };
9010     }
9011   }
9012
9013   jresult = (void *)result;
9014   return jresult;
9015 }
9016
9017
9018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9019   void * jresult ;
9020   Dali::Uint16Pair *arg1 = 0 ;
9021   Dali::Uint16Pair *result = 0 ;
9022
9023   arg1 = (Dali::Uint16Pair *)jarg1;
9024   if (!arg1) {
9025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9026     return 0;
9027   }
9028   {
9029     try {
9030       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9031     } catch (std::out_of_range& e) {
9032       {
9033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9034       };
9035     } catch (std::exception& e) {
9036       {
9037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9038       };
9039     } catch (Dali::DaliException e) {
9040       {
9041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9042       };
9043     } catch (...) {
9044       {
9045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9046       };
9047     }
9048   }
9049
9050   jresult = (void *)result;
9051   return jresult;
9052 }
9053
9054
9055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9056   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9057   uint16_t arg2 ;
9058
9059   arg1 = (Dali::Uint16Pair *)jarg1;
9060   arg2 = (uint16_t)jarg2;
9061   {
9062     try {
9063       (arg1)->SetWidth(arg2);
9064     } catch (std::out_of_range& e) {
9065       {
9066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9067       };
9068     } catch (std::exception& e) {
9069       {
9070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9071       };
9072     } catch (Dali::DaliException e) {
9073       {
9074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9075       };
9076     } catch (...) {
9077       {
9078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9079       };
9080     }
9081   }
9082
9083 }
9084
9085
9086 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9087   unsigned short jresult ;
9088   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9089   uint16_t result;
9090
9091   arg1 = (Dali::Uint16Pair *)jarg1;
9092   {
9093     try {
9094       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9095     } catch (std::out_of_range& e) {
9096       {
9097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9098       };
9099     } catch (std::exception& e) {
9100       {
9101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9102       };
9103     } catch (Dali::DaliException e) {
9104       {
9105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9106       };
9107     } catch (...) {
9108       {
9109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9110       };
9111     }
9112   }
9113
9114   jresult = result;
9115   return jresult;
9116 }
9117
9118
9119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9120   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9121   uint16_t arg2 ;
9122
9123   arg1 = (Dali::Uint16Pair *)jarg1;
9124   arg2 = (uint16_t)jarg2;
9125   {
9126     try {
9127       (arg1)->SetHeight(arg2);
9128     } catch (std::out_of_range& e) {
9129       {
9130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9131       };
9132     } catch (std::exception& e) {
9133       {
9134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9135       };
9136     } catch (Dali::DaliException e) {
9137       {
9138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9139       };
9140     } catch (...) {
9141       {
9142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9143       };
9144     }
9145   }
9146
9147 }
9148
9149
9150 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9151   unsigned short jresult ;
9152   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9153   uint16_t result;
9154
9155   arg1 = (Dali::Uint16Pair *)jarg1;
9156   {
9157     try {
9158       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9159     } catch (std::out_of_range& e) {
9160       {
9161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9162       };
9163     } catch (std::exception& e) {
9164       {
9165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9166       };
9167     } catch (Dali::DaliException e) {
9168       {
9169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9170       };
9171     } catch (...) {
9172       {
9173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9174       };
9175     }
9176   }
9177
9178   jresult = result;
9179   return jresult;
9180 }
9181
9182
9183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9184   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9185   uint16_t arg2 ;
9186
9187   arg1 = (Dali::Uint16Pair *)jarg1;
9188   arg2 = (uint16_t)jarg2;
9189   {
9190     try {
9191       (arg1)->SetX(arg2);
9192     } catch (std::out_of_range& e) {
9193       {
9194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9195       };
9196     } catch (std::exception& e) {
9197       {
9198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9199       };
9200     } catch (Dali::DaliException e) {
9201       {
9202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9203       };
9204     } catch (...) {
9205       {
9206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9207       };
9208     }
9209   }
9210
9211 }
9212
9213
9214 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9215   unsigned short jresult ;
9216   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9217   uint16_t result;
9218
9219   arg1 = (Dali::Uint16Pair *)jarg1;
9220   {
9221     try {
9222       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9223     } catch (std::out_of_range& e) {
9224       {
9225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9226       };
9227     } catch (std::exception& e) {
9228       {
9229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9230       };
9231     } catch (Dali::DaliException e) {
9232       {
9233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9234       };
9235     } catch (...) {
9236       {
9237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9238       };
9239     }
9240   }
9241
9242   jresult = result;
9243   return jresult;
9244 }
9245
9246
9247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9248   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9249   uint16_t arg2 ;
9250
9251   arg1 = (Dali::Uint16Pair *)jarg1;
9252   arg2 = (uint16_t)jarg2;
9253   {
9254     try {
9255       (arg1)->SetY(arg2);
9256     } catch (std::out_of_range& e) {
9257       {
9258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9259       };
9260     } catch (std::exception& e) {
9261       {
9262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9263       };
9264     } catch (Dali::DaliException e) {
9265       {
9266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9267       };
9268     } catch (...) {
9269       {
9270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9271       };
9272     }
9273   }
9274
9275 }
9276
9277
9278 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9279   unsigned short jresult ;
9280   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9281   uint16_t result;
9282
9283   arg1 = (Dali::Uint16Pair *)jarg1;
9284   {
9285     try {
9286       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9287     } catch (std::out_of_range& e) {
9288       {
9289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9290       };
9291     } catch (std::exception& e) {
9292       {
9293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9294       };
9295     } catch (Dali::DaliException e) {
9296       {
9297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9298       };
9299     } catch (...) {
9300       {
9301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9302       };
9303     }
9304   }
9305
9306   jresult = result;
9307   return jresult;
9308 }
9309
9310
9311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9312   void * jresult ;
9313   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9314   Dali::Uint16Pair *arg2 = 0 ;
9315   Dali::Uint16Pair *result = 0 ;
9316
9317   arg1 = (Dali::Uint16Pair *)jarg1;
9318   arg2 = (Dali::Uint16Pair *)jarg2;
9319   if (!arg2) {
9320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9321     return 0;
9322   }
9323   {
9324     try {
9325       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9326     } catch (std::out_of_range& e) {
9327       {
9328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9329       };
9330     } catch (std::exception& e) {
9331       {
9332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9333       };
9334     } catch (Dali::DaliException e) {
9335       {
9336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9337       };
9338     } catch (...) {
9339       {
9340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9341       };
9342     }
9343   }
9344
9345   jresult = (void *)result;
9346   return jresult;
9347 }
9348
9349
9350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9351   unsigned int jresult ;
9352   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9353   Dali::Uint16Pair *arg2 = 0 ;
9354   bool result;
9355
9356   arg1 = (Dali::Uint16Pair *)jarg1;
9357   arg2 = (Dali::Uint16Pair *)jarg2;
9358   if (!arg2) {
9359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9360     return 0;
9361   }
9362   {
9363     try {
9364       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9365     } catch (std::out_of_range& e) {
9366       {
9367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9368       };
9369     } catch (std::exception& e) {
9370       {
9371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9372       };
9373     } catch (Dali::DaliException e) {
9374       {
9375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9376       };
9377     } catch (...) {
9378       {
9379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9380       };
9381     }
9382   }
9383
9384   jresult = result;
9385   return jresult;
9386 }
9387
9388
9389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9390   unsigned int jresult ;
9391   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9392   Dali::Uint16Pair *arg2 = 0 ;
9393   bool result;
9394
9395   arg1 = (Dali::Uint16Pair *)jarg1;
9396   arg2 = (Dali::Uint16Pair *)jarg2;
9397   if (!arg2) {
9398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9399     return 0;
9400   }
9401   {
9402     try {
9403       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9404     } catch (std::out_of_range& e) {
9405       {
9406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9407       };
9408     } catch (std::exception& e) {
9409       {
9410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9411       };
9412     } catch (Dali::DaliException e) {
9413       {
9414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9415       };
9416     } catch (...) {
9417       {
9418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9419       };
9420     }
9421   }
9422
9423   jresult = result;
9424   return jresult;
9425 }
9426
9427
9428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9429   unsigned int jresult ;
9430   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9431   Dali::Uint16Pair *arg2 = 0 ;
9432   bool result;
9433
9434   arg1 = (Dali::Uint16Pair *)jarg1;
9435   arg2 = (Dali::Uint16Pair *)jarg2;
9436   if (!arg2) {
9437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9438     return 0;
9439   }
9440   {
9441     try {
9442       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9443     } catch (std::out_of_range& e) {
9444       {
9445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9446       };
9447     } catch (std::exception& e) {
9448       {
9449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9450       };
9451     } catch (Dali::DaliException e) {
9452       {
9453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9454       };
9455     } catch (...) {
9456       {
9457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9458       };
9459     }
9460   }
9461
9462   jresult = result;
9463   return jresult;
9464 }
9465
9466
9467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9468   unsigned int jresult ;
9469   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9470   Dali::Uint16Pair *arg2 = 0 ;
9471   bool result;
9472
9473   arg1 = (Dali::Uint16Pair *)jarg1;
9474   arg2 = (Dali::Uint16Pair *)jarg2;
9475   if (!arg2) {
9476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9477     return 0;
9478   }
9479   {
9480     try {
9481       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9482     } catch (std::out_of_range& e) {
9483       {
9484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9485       };
9486     } catch (std::exception& e) {
9487       {
9488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9489       };
9490     } catch (Dali::DaliException e) {
9491       {
9492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9493       };
9494     } catch (...) {
9495       {
9496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9497       };
9498     }
9499   }
9500
9501   jresult = result;
9502   return jresult;
9503 }
9504
9505
9506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9507   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9508
9509   arg1 = (Dali::Uint16Pair *)jarg1;
9510   {
9511     try {
9512       delete arg1;
9513     } catch (std::out_of_range& e) {
9514       {
9515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9516       };
9517     } catch (std::exception& e) {
9518       {
9519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9520       };
9521     } catch (Dali::DaliException e) {
9522       {
9523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9524       };
9525     } catch (...) {
9526       {
9527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9528       };
9529     }
9530   }
9531
9532 }
9533
9534
9535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9536   void * jresult ;
9537   Dali::Degree *result = 0 ;
9538
9539   {
9540     try {
9541       result = (Dali::Degree *)new Dali::Degree();
9542     } catch (std::out_of_range& e) {
9543       {
9544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9545       };
9546     } catch (std::exception& e) {
9547       {
9548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9549       };
9550     } catch (Dali::DaliException e) {
9551       {
9552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9553       };
9554     } catch (...) {
9555       {
9556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9557       };
9558     }
9559   }
9560
9561   jresult = (void *)result;
9562   return jresult;
9563 }
9564
9565
9566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9567   void * jresult ;
9568   float arg1 ;
9569   Dali::Degree *result = 0 ;
9570
9571   arg1 = (float)jarg1;
9572   {
9573     try {
9574       result = (Dali::Degree *)new Dali::Degree(arg1);
9575     } catch (std::out_of_range& e) {
9576       {
9577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9578       };
9579     } catch (std::exception& e) {
9580       {
9581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9582       };
9583     } catch (Dali::DaliException e) {
9584       {
9585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9586       };
9587     } catch (...) {
9588       {
9589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9590       };
9591     }
9592   }
9593
9594   jresult = (void *)result;
9595   return jresult;
9596 }
9597
9598
9599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9600   void * jresult ;
9601   Dali::Radian arg1 ;
9602   Dali::Radian *argp1 ;
9603   Dali::Degree *result = 0 ;
9604
9605   argp1 = (Dali::Radian *)jarg1;
9606   if (!argp1) {
9607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9608     return 0;
9609   }
9610   arg1 = *argp1;
9611   {
9612     try {
9613       result = (Dali::Degree *)new Dali::Degree(arg1);
9614     } catch (std::out_of_range& e) {
9615       {
9616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9617       };
9618     } catch (std::exception& e) {
9619       {
9620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9621       };
9622     } catch (Dali::DaliException e) {
9623       {
9624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9625       };
9626     } catch (...) {
9627       {
9628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9629       };
9630     }
9631   }
9632
9633   jresult = (void *)result;
9634   return jresult;
9635 }
9636
9637
9638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9639   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9640   float arg2 ;
9641
9642   arg1 = (Dali::Degree *)jarg1;
9643   arg2 = (float)jarg2;
9644   if (arg1) (arg1)->degree = arg2;
9645 }
9646
9647
9648 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9649   float jresult ;
9650   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9651   float result;
9652
9653   arg1 = (Dali::Degree *)jarg1;
9654   result = (float) ((arg1)->degree);
9655   jresult = result;
9656   return jresult;
9657 }
9658
9659
9660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9661   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9662
9663   arg1 = (Dali::Degree *)jarg1;
9664   {
9665     try {
9666       delete arg1;
9667     } catch (std::out_of_range& e) {
9668       {
9669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9670       };
9671     } catch (std::exception& e) {
9672       {
9673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9674       };
9675     } catch (Dali::DaliException e) {
9676       {
9677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9678       };
9679     } catch (...) {
9680       {
9681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9682       };
9683     }
9684   }
9685
9686 }
9687
9688
9689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9690   void * jresult ;
9691   Dali::Radian *result = 0 ;
9692
9693   result = (Dali::Radian *)&Dali::ANGLE_360;
9694   jresult = (void *)result;
9695   return jresult;
9696 }
9697
9698
9699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9700   void * jresult ;
9701   Dali::Radian *result = 0 ;
9702
9703   result = (Dali::Radian *)&Dali::ANGLE_315;
9704   jresult = (void *)result;
9705   return jresult;
9706 }
9707
9708
9709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9710   void * jresult ;
9711   Dali::Radian *result = 0 ;
9712
9713   result = (Dali::Radian *)&Dali::ANGLE_270;
9714   jresult = (void *)result;
9715   return jresult;
9716 }
9717
9718
9719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9720   void * jresult ;
9721   Dali::Radian *result = 0 ;
9722
9723   result = (Dali::Radian *)&Dali::ANGLE_225;
9724   jresult = (void *)result;
9725   return jresult;
9726 }
9727
9728
9729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9730   void * jresult ;
9731   Dali::Radian *result = 0 ;
9732
9733   result = (Dali::Radian *)&Dali::ANGLE_180;
9734   jresult = (void *)result;
9735   return jresult;
9736 }
9737
9738
9739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9740   void * jresult ;
9741   Dali::Radian *result = 0 ;
9742
9743   result = (Dali::Radian *)&Dali::ANGLE_135;
9744   jresult = (void *)result;
9745   return jresult;
9746 }
9747
9748
9749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9750   void * jresult ;
9751   Dali::Radian *result = 0 ;
9752
9753   result = (Dali::Radian *)&Dali::ANGLE_120;
9754   jresult = (void *)result;
9755   return jresult;
9756 }
9757
9758
9759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9760   void * jresult ;
9761   Dali::Radian *result = 0 ;
9762
9763   result = (Dali::Radian *)&Dali::ANGLE_90;
9764   jresult = (void *)result;
9765   return jresult;
9766 }
9767
9768
9769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9770   void * jresult ;
9771   Dali::Radian *result = 0 ;
9772
9773   result = (Dali::Radian *)&Dali::ANGLE_60;
9774   jresult = (void *)result;
9775   return jresult;
9776 }
9777
9778
9779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9780   void * jresult ;
9781   Dali::Radian *result = 0 ;
9782
9783   result = (Dali::Radian *)&Dali::ANGLE_45;
9784   jresult = (void *)result;
9785   return jresult;
9786 }
9787
9788
9789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9790   void * jresult ;
9791   Dali::Radian *result = 0 ;
9792
9793   result = (Dali::Radian *)&Dali::ANGLE_30;
9794   jresult = (void *)result;
9795   return jresult;
9796 }
9797
9798
9799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9800   void * jresult ;
9801   Dali::Radian *result = 0 ;
9802
9803   result = (Dali::Radian *)&Dali::ANGLE_0;
9804   jresult = (void *)result;
9805   return jresult;
9806 }
9807
9808
9809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9810   unsigned int jresult ;
9811   Dali::Degree *arg1 = 0 ;
9812   Dali::Degree *arg2 = 0 ;
9813   bool result;
9814
9815   arg1 = (Dali::Degree *)jarg1;
9816   if (!arg1) {
9817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9818     return 0;
9819   }
9820   arg2 = (Dali::Degree *)jarg2;
9821   if (!arg2) {
9822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9823     return 0;
9824   }
9825   {
9826     try {
9827       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9828     } catch (std::out_of_range& e) {
9829       {
9830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9831       };
9832     } catch (std::exception& e) {
9833       {
9834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9835       };
9836     } catch (Dali::DaliException e) {
9837       {
9838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9839       };
9840     } catch (...) {
9841       {
9842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9843       };
9844     }
9845   }
9846
9847   jresult = result;
9848   return jresult;
9849 }
9850
9851
9852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9853   unsigned int jresult ;
9854   Dali::Degree *arg1 = 0 ;
9855   Dali::Degree *arg2 = 0 ;
9856   bool result;
9857
9858   arg1 = (Dali::Degree *)jarg1;
9859   if (!arg1) {
9860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9861     return 0;
9862   }
9863   arg2 = (Dali::Degree *)jarg2;
9864   if (!arg2) {
9865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9866     return 0;
9867   }
9868   {
9869     try {
9870       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9871     } catch (std::out_of_range& e) {
9872       {
9873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9874       };
9875     } catch (std::exception& e) {
9876       {
9877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9878       };
9879     } catch (Dali::DaliException e) {
9880       {
9881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9882       };
9883     } catch (...) {
9884       {
9885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9886       };
9887     }
9888   }
9889
9890   jresult = result;
9891   return jresult;
9892 }
9893
9894
9895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9896   void * jresult ;
9897   Dali::Degree arg1 ;
9898   float arg2 ;
9899   float arg3 ;
9900   Dali::Degree *argp1 ;
9901   Dali::Degree result;
9902
9903   argp1 = (Dali::Degree *)jarg1;
9904   if (!argp1) {
9905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9906     return 0;
9907   }
9908   arg1 = *argp1;
9909   arg2 = (float)jarg2;
9910   arg3 = (float)jarg3;
9911   {
9912     try {
9913       result = Dali::Clamp(arg1,arg2,arg3);
9914     } catch (std::out_of_range& e) {
9915       {
9916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9917       };
9918     } catch (std::exception& e) {
9919       {
9920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9921       };
9922     } catch (Dali::DaliException e) {
9923       {
9924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9925       };
9926     } catch (...) {
9927       {
9928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9929       };
9930     }
9931   }
9932
9933   jresult = new Dali::Degree((const Dali::Degree &)result);
9934   return jresult;
9935 }
9936
9937
9938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9939   void * jresult ;
9940   Dali::Radian *result = 0 ;
9941
9942   {
9943     try {
9944       result = (Dali::Radian *)new Dali::Radian();
9945     } catch (std::out_of_range& e) {
9946       {
9947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9948       };
9949     } catch (std::exception& e) {
9950       {
9951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9952       };
9953     } catch (Dali::DaliException e) {
9954       {
9955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9956       };
9957     } catch (...) {
9958       {
9959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9960       };
9961     }
9962   }
9963
9964   jresult = (void *)result;
9965   return jresult;
9966 }
9967
9968
9969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9970   void * jresult ;
9971   float arg1 ;
9972   Dali::Radian *result = 0 ;
9973
9974   arg1 = (float)jarg1;
9975   {
9976     try {
9977       result = (Dali::Radian *)new Dali::Radian(arg1);
9978     } catch (std::out_of_range& e) {
9979       {
9980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9981       };
9982     } catch (std::exception& e) {
9983       {
9984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9985       };
9986     } catch (Dali::DaliException e) {
9987       {
9988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9989       };
9990     } catch (...) {
9991       {
9992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9993       };
9994     }
9995   }
9996
9997   jresult = (void *)result;
9998   return jresult;
9999 }
10000
10001
10002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10003   void * jresult ;
10004   Dali::Degree arg1 ;
10005   Dali::Degree *argp1 ;
10006   Dali::Radian *result = 0 ;
10007
10008   argp1 = (Dali::Degree *)jarg1;
10009   if (!argp1) {
10010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10011     return 0;
10012   }
10013   arg1 = *argp1;
10014   {
10015     try {
10016       result = (Dali::Radian *)new Dali::Radian(arg1);
10017     } catch (std::out_of_range& e) {
10018       {
10019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10020       };
10021     } catch (std::exception& e) {
10022       {
10023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10024       };
10025     } catch (Dali::DaliException e) {
10026       {
10027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10028       };
10029     } catch (...) {
10030       {
10031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10032       };
10033     }
10034   }
10035
10036   jresult = (void *)result;
10037   return jresult;
10038 }
10039
10040
10041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10042   void * jresult ;
10043   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10044   float arg2 ;
10045   Dali::Radian *result = 0 ;
10046
10047   arg1 = (Dali::Radian *)jarg1;
10048   arg2 = (float)jarg2;
10049   {
10050     try {
10051       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10052     } catch (std::out_of_range& e) {
10053       {
10054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10055       };
10056     } catch (std::exception& e) {
10057       {
10058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10059       };
10060     } catch (Dali::DaliException e) {
10061       {
10062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10063       };
10064     } catch (...) {
10065       {
10066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10067       };
10068     }
10069   }
10070
10071   jresult = (void *)result;
10072   return jresult;
10073 }
10074
10075
10076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10077   void * jresult ;
10078   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10079   Dali::Degree arg2 ;
10080   Dali::Degree *argp2 ;
10081   Dali::Radian *result = 0 ;
10082
10083   arg1 = (Dali::Radian *)jarg1;
10084   argp2 = (Dali::Degree *)jarg2;
10085   if (!argp2) {
10086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10087     return 0;
10088   }
10089   arg2 = *argp2;
10090   {
10091     try {
10092       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10093     } catch (std::out_of_range& e) {
10094       {
10095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10096       };
10097     } catch (std::exception& e) {
10098       {
10099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10100       };
10101     } catch (Dali::DaliException e) {
10102       {
10103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10104       };
10105     } catch (...) {
10106       {
10107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10108       };
10109     }
10110   }
10111
10112   jresult = (void *)result;
10113   return jresult;
10114 }
10115
10116
10117 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10118   float jresult ;
10119   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10120   float result;
10121
10122   arg1 = (Dali::Radian *)jarg1;
10123   {
10124     try {
10125       result = (float)((Dali::Radian const *)arg1)->operator float();
10126     } catch (std::out_of_range& e) {
10127       {
10128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10129       };
10130     } catch (std::exception& e) {
10131       {
10132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10133       };
10134     } catch (Dali::DaliException e) {
10135       {
10136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10137       };
10138     } catch (...) {
10139       {
10140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10141       };
10142     }
10143   }
10144
10145   jresult = result;
10146   return jresult;
10147 }
10148
10149
10150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10151   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10152   float arg2 ;
10153
10154   arg1 = (Dali::Radian *)jarg1;
10155   arg2 = (float)jarg2;
10156   if (arg1) (arg1)->radian = arg2;
10157 }
10158
10159
10160 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10161   float jresult ;
10162   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10163   float result;
10164
10165   arg1 = (Dali::Radian *)jarg1;
10166   result = (float) ((arg1)->radian);
10167   jresult = result;
10168   return jresult;
10169 }
10170
10171
10172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10173   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10174
10175   arg1 = (Dali::Radian *)jarg1;
10176   {
10177     try {
10178       delete arg1;
10179     } catch (std::out_of_range& e) {
10180       {
10181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10182       };
10183     } catch (std::exception& e) {
10184       {
10185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10186       };
10187     } catch (Dali::DaliException e) {
10188       {
10189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10190       };
10191     } catch (...) {
10192       {
10193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10194       };
10195     }
10196   }
10197
10198 }
10199
10200
10201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10202   unsigned int jresult ;
10203   Dali::Radian arg1 ;
10204   Dali::Radian arg2 ;
10205   Dali::Radian *argp1 ;
10206   Dali::Radian *argp2 ;
10207   bool result;
10208
10209   argp1 = (Dali::Radian *)jarg1;
10210   if (!argp1) {
10211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10212     return 0;
10213   }
10214   arg1 = *argp1;
10215   argp2 = (Dali::Radian *)jarg2;
10216   if (!argp2) {
10217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10218     return 0;
10219   }
10220   arg2 = *argp2;
10221   {
10222     try {
10223       result = (bool)Dali::operator ==(arg1,arg2);
10224     } catch (std::out_of_range& e) {
10225       {
10226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10227       };
10228     } catch (std::exception& e) {
10229       {
10230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10231       };
10232     } catch (Dali::DaliException e) {
10233       {
10234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10235       };
10236     } catch (...) {
10237       {
10238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10239       };
10240     }
10241   }
10242
10243   jresult = result;
10244   return jresult;
10245 }
10246
10247
10248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10249   unsigned int jresult ;
10250   Dali::Radian arg1 ;
10251   Dali::Radian arg2 ;
10252   Dali::Radian *argp1 ;
10253   Dali::Radian *argp2 ;
10254   bool result;
10255
10256   argp1 = (Dali::Radian *)jarg1;
10257   if (!argp1) {
10258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10259     return 0;
10260   }
10261   arg1 = *argp1;
10262   argp2 = (Dali::Radian *)jarg2;
10263   if (!argp2) {
10264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10265     return 0;
10266   }
10267   arg2 = *argp2;
10268   {
10269     try {
10270       result = (bool)Dali::operator !=(arg1,arg2);
10271     } catch (std::out_of_range& e) {
10272       {
10273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10274       };
10275     } catch (std::exception& e) {
10276       {
10277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10278       };
10279     } catch (Dali::DaliException e) {
10280       {
10281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10282       };
10283     } catch (...) {
10284       {
10285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10286       };
10287     }
10288   }
10289
10290   jresult = result;
10291   return jresult;
10292 }
10293
10294
10295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10296   unsigned int jresult ;
10297   Dali::Radian arg1 ;
10298   Dali::Degree arg2 ;
10299   Dali::Radian *argp1 ;
10300   Dali::Degree *argp2 ;
10301   bool result;
10302
10303   argp1 = (Dali::Radian *)jarg1;
10304   if (!argp1) {
10305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10306     return 0;
10307   }
10308   arg1 = *argp1;
10309   argp2 = (Dali::Degree *)jarg2;
10310   if (!argp2) {
10311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10312     return 0;
10313   }
10314   arg2 = *argp2;
10315   {
10316     try {
10317       result = (bool)Dali::operator ==(arg1,arg2);
10318     } catch (std::out_of_range& e) {
10319       {
10320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10321       };
10322     } catch (std::exception& e) {
10323       {
10324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10325       };
10326     } catch (Dali::DaliException e) {
10327       {
10328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10329       };
10330     } catch (...) {
10331       {
10332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10333       };
10334     }
10335   }
10336
10337   jresult = result;
10338   return jresult;
10339 }
10340
10341
10342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10343   unsigned int jresult ;
10344   Dali::Radian arg1 ;
10345   Dali::Degree arg2 ;
10346   Dali::Radian *argp1 ;
10347   Dali::Degree *argp2 ;
10348   bool result;
10349
10350   argp1 = (Dali::Radian *)jarg1;
10351   if (!argp1) {
10352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10353     return 0;
10354   }
10355   arg1 = *argp1;
10356   argp2 = (Dali::Degree *)jarg2;
10357   if (!argp2) {
10358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10359     return 0;
10360   }
10361   arg2 = *argp2;
10362   {
10363     try {
10364       result = (bool)Dali::operator !=(arg1,arg2);
10365     } catch (std::out_of_range& e) {
10366       {
10367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10368       };
10369     } catch (std::exception& e) {
10370       {
10371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10372       };
10373     } catch (Dali::DaliException e) {
10374       {
10375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10376       };
10377     } catch (...) {
10378       {
10379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10380       };
10381     }
10382   }
10383
10384   jresult = result;
10385   return jresult;
10386 }
10387
10388
10389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10390   unsigned int jresult ;
10391   Dali::Degree arg1 ;
10392   Dali::Radian arg2 ;
10393   Dali::Degree *argp1 ;
10394   Dali::Radian *argp2 ;
10395   bool result;
10396
10397   argp1 = (Dali::Degree *)jarg1;
10398   if (!argp1) {
10399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10400     return 0;
10401   }
10402   arg1 = *argp1;
10403   argp2 = (Dali::Radian *)jarg2;
10404   if (!argp2) {
10405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10406     return 0;
10407   }
10408   arg2 = *argp2;
10409   {
10410     try {
10411       result = (bool)Dali::operator ==(arg1,arg2);
10412     } catch (std::out_of_range& e) {
10413       {
10414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10415       };
10416     } catch (std::exception& e) {
10417       {
10418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10419       };
10420     } catch (Dali::DaliException e) {
10421       {
10422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10423       };
10424     } catch (...) {
10425       {
10426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10427       };
10428     }
10429   }
10430
10431   jresult = result;
10432   return jresult;
10433 }
10434
10435
10436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10437   unsigned int jresult ;
10438   Dali::Degree arg1 ;
10439   Dali::Radian arg2 ;
10440   Dali::Degree *argp1 ;
10441   Dali::Radian *argp2 ;
10442   bool result;
10443
10444   argp1 = (Dali::Degree *)jarg1;
10445   if (!argp1) {
10446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10447     return 0;
10448   }
10449   arg1 = *argp1;
10450   argp2 = (Dali::Radian *)jarg2;
10451   if (!argp2) {
10452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10453     return 0;
10454   }
10455   arg2 = *argp2;
10456   {
10457     try {
10458       result = (bool)Dali::operator !=(arg1,arg2);
10459     } catch (std::out_of_range& e) {
10460       {
10461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10462       };
10463     } catch (std::exception& e) {
10464       {
10465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10466       };
10467     } catch (Dali::DaliException e) {
10468       {
10469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10470       };
10471     } catch (...) {
10472       {
10473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10474       };
10475     }
10476   }
10477
10478   jresult = result;
10479   return jresult;
10480 }
10481
10482
10483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10484   unsigned int jresult ;
10485   Dali::Radian arg1 ;
10486   Dali::Radian arg2 ;
10487   Dali::Radian *argp1 ;
10488   Dali::Radian *argp2 ;
10489   bool result;
10490
10491   argp1 = (Dali::Radian *)jarg1;
10492   if (!argp1) {
10493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10494     return 0;
10495   }
10496   arg1 = *argp1;
10497   argp2 = (Dali::Radian *)jarg2;
10498   if (!argp2) {
10499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10500     return 0;
10501   }
10502   arg2 = *argp2;
10503   {
10504     try {
10505       result = (bool)Dali::operator >(arg1,arg2);
10506     } catch (std::out_of_range& e) {
10507       {
10508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10509       };
10510     } catch (std::exception& e) {
10511       {
10512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10513       };
10514     } catch (Dali::DaliException e) {
10515       {
10516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10517       };
10518     } catch (...) {
10519       {
10520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10521       };
10522     }
10523   }
10524
10525   jresult = result;
10526   return jresult;
10527 }
10528
10529
10530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10531   unsigned int jresult ;
10532   Dali::Radian arg1 ;
10533   Dali::Degree arg2 ;
10534   Dali::Radian *argp1 ;
10535   Dali::Degree *argp2 ;
10536   bool result;
10537
10538   argp1 = (Dali::Radian *)jarg1;
10539   if (!argp1) {
10540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10541     return 0;
10542   }
10543   arg1 = *argp1;
10544   argp2 = (Dali::Degree *)jarg2;
10545   if (!argp2) {
10546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10547     return 0;
10548   }
10549   arg2 = *argp2;
10550   {
10551     try {
10552       result = (bool)Dali::operator >(arg1,arg2);
10553     } catch (std::out_of_range& e) {
10554       {
10555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10556       };
10557     } catch (std::exception& e) {
10558       {
10559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10560       };
10561     } catch (Dali::DaliException e) {
10562       {
10563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10564       };
10565     } catch (...) {
10566       {
10567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10568       };
10569     }
10570   }
10571
10572   jresult = result;
10573   return jresult;
10574 }
10575
10576
10577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10578   unsigned int jresult ;
10579   Dali::Degree arg1 ;
10580   Dali::Radian arg2 ;
10581   Dali::Degree *argp1 ;
10582   Dali::Radian *argp2 ;
10583   bool result;
10584
10585   argp1 = (Dali::Degree *)jarg1;
10586   if (!argp1) {
10587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10588     return 0;
10589   }
10590   arg1 = *argp1;
10591   argp2 = (Dali::Radian *)jarg2;
10592   if (!argp2) {
10593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10594     return 0;
10595   }
10596   arg2 = *argp2;
10597   {
10598     try {
10599       result = (bool)Dali::operator >(arg1,arg2);
10600     } catch (std::out_of_range& e) {
10601       {
10602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10603       };
10604     } catch (std::exception& e) {
10605       {
10606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10607       };
10608     } catch (Dali::DaliException e) {
10609       {
10610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10611       };
10612     } catch (...) {
10613       {
10614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10615       };
10616     }
10617   }
10618
10619   jresult = result;
10620   return jresult;
10621 }
10622
10623
10624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10625   unsigned int jresult ;
10626   Dali::Radian arg1 ;
10627   Dali::Radian arg2 ;
10628   Dali::Radian *argp1 ;
10629   Dali::Radian *argp2 ;
10630   bool result;
10631
10632   argp1 = (Dali::Radian *)jarg1;
10633   if (!argp1) {
10634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10635     return 0;
10636   }
10637   arg1 = *argp1;
10638   argp2 = (Dali::Radian *)jarg2;
10639   if (!argp2) {
10640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10641     return 0;
10642   }
10643   arg2 = *argp2;
10644   {
10645     try {
10646       result = (bool)Dali::operator <(arg1,arg2);
10647     } catch (std::out_of_range& e) {
10648       {
10649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10650       };
10651     } catch (std::exception& e) {
10652       {
10653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10654       };
10655     } catch (Dali::DaliException e) {
10656       {
10657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10658       };
10659     } catch (...) {
10660       {
10661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10662       };
10663     }
10664   }
10665
10666   jresult = result;
10667   return jresult;
10668 }
10669
10670
10671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10672   unsigned int jresult ;
10673   Dali::Radian arg1 ;
10674   Dali::Degree arg2 ;
10675   Dali::Radian *argp1 ;
10676   Dali::Degree *argp2 ;
10677   bool result;
10678
10679   argp1 = (Dali::Radian *)jarg1;
10680   if (!argp1) {
10681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10682     return 0;
10683   }
10684   arg1 = *argp1;
10685   argp2 = (Dali::Degree *)jarg2;
10686   if (!argp2) {
10687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10688     return 0;
10689   }
10690   arg2 = *argp2;
10691   {
10692     try {
10693       result = (bool)Dali::operator <(arg1,arg2);
10694     } catch (std::out_of_range& e) {
10695       {
10696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10697       };
10698     } catch (std::exception& e) {
10699       {
10700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10701       };
10702     } catch (Dali::DaliException e) {
10703       {
10704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10705       };
10706     } catch (...) {
10707       {
10708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10709       };
10710     }
10711   }
10712
10713   jresult = result;
10714   return jresult;
10715 }
10716
10717
10718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10719   unsigned int jresult ;
10720   Dali::Degree arg1 ;
10721   Dali::Radian arg2 ;
10722   Dali::Degree *argp1 ;
10723   Dali::Radian *argp2 ;
10724   bool result;
10725
10726   argp1 = (Dali::Degree *)jarg1;
10727   if (!argp1) {
10728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10729     return 0;
10730   }
10731   arg1 = *argp1;
10732   argp2 = (Dali::Radian *)jarg2;
10733   if (!argp2) {
10734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10735     return 0;
10736   }
10737   arg2 = *argp2;
10738   {
10739     try {
10740       result = (bool)Dali::operator <(arg1,arg2);
10741     } catch (std::out_of_range& e) {
10742       {
10743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10744       };
10745     } catch (std::exception& e) {
10746       {
10747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10748       };
10749     } catch (Dali::DaliException e) {
10750       {
10751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10752       };
10753     } catch (...) {
10754       {
10755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10756       };
10757     }
10758   }
10759
10760   jresult = result;
10761   return jresult;
10762 }
10763
10764
10765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10766   void * jresult ;
10767   Dali::Radian arg1 ;
10768   float arg2 ;
10769   Dali::Radian *argp1 ;
10770   Dali::Radian result;
10771
10772   argp1 = (Dali::Radian *)jarg1;
10773   if (!argp1) {
10774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10775     return 0;
10776   }
10777   arg1 = *argp1;
10778   arg2 = (float)jarg2;
10779   {
10780     try {
10781       result = Dali::operator *(arg1,arg2);
10782     } catch (std::out_of_range& e) {
10783       {
10784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10785       };
10786     } catch (std::exception& e) {
10787       {
10788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10789       };
10790     } catch (Dali::DaliException e) {
10791       {
10792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10793       };
10794     } catch (...) {
10795       {
10796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10797       };
10798     }
10799   }
10800
10801   jresult = new Dali::Radian((const Dali::Radian &)result);
10802   return jresult;
10803 }
10804
10805
10806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10807   void * jresult ;
10808   Dali::Radian arg1 ;
10809   Dali::Radian *argp1 ;
10810   Dali::Radian result;
10811
10812   argp1 = (Dali::Radian *)jarg1;
10813   if (!argp1) {
10814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10815     return 0;
10816   }
10817   arg1 = *argp1;
10818   {
10819     try {
10820       result = Dali::operator -(arg1);
10821     } catch (std::out_of_range& e) {
10822       {
10823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10824       };
10825     } catch (std::exception& e) {
10826       {
10827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10828       };
10829     } catch (Dali::DaliException e) {
10830       {
10831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10832       };
10833     } catch (...) {
10834       {
10835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10836       };
10837     }
10838   }
10839
10840   jresult = new Dali::Radian((const Dali::Radian &)result);
10841   return jresult;
10842 }
10843
10844
10845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10846   void * jresult ;
10847   Dali::Radian arg1 ;
10848   float arg2 ;
10849   float arg3 ;
10850   Dali::Radian *argp1 ;
10851   Dali::Radian result;
10852
10853   argp1 = (Dali::Radian *)jarg1;
10854   if (!argp1) {
10855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10856     return 0;
10857   }
10858   arg1 = *argp1;
10859   arg2 = (float)jarg2;
10860   arg3 = (float)jarg3;
10861   {
10862     try {
10863       result = Dali::Clamp(arg1,arg2,arg3);
10864     } catch (std::out_of_range& e) {
10865       {
10866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10867       };
10868     } catch (std::exception& e) {
10869       {
10870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10871       };
10872     } catch (Dali::DaliException e) {
10873       {
10874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10875       };
10876     } catch (...) {
10877       {
10878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10879       };
10880     }
10881   }
10882
10883   jresult = new Dali::Radian((const Dali::Radian &)result);
10884   return jresult;
10885 }
10886
10887
10888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10889   void * jresult ;
10890   Dali::Quaternion *result = 0 ;
10891
10892   {
10893     try {
10894       result = (Dali::Quaternion *)new Dali::Quaternion();
10895     } catch (std::out_of_range& e) {
10896       {
10897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10898       };
10899     } catch (std::exception& e) {
10900       {
10901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10902       };
10903     } catch (Dali::DaliException e) {
10904       {
10905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10906       };
10907     } catch (...) {
10908       {
10909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10910       };
10911     }
10912   }
10913
10914   jresult = (void *)result;
10915   return jresult;
10916 }
10917
10918
10919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10920   void * jresult ;
10921   Dali::Radian arg1 ;
10922   Dali::Vector3 *arg2 = 0 ;
10923   Dali::Radian *argp1 ;
10924   Dali::Quaternion *result = 0 ;
10925
10926   argp1 = (Dali::Radian *)jarg1;
10927   if (!argp1) {
10928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10929     return 0;
10930   }
10931   arg1 = *argp1;
10932   arg2 = (Dali::Vector3 *)jarg2;
10933   if (!arg2) {
10934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10935     return 0;
10936   }
10937   {
10938     try {
10939       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10940     } catch (std::out_of_range& e) {
10941       {
10942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10943       };
10944     } catch (std::exception& e) {
10945       {
10946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10947       };
10948     } catch (Dali::DaliException e) {
10949       {
10950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10951       };
10952     } catch (...) {
10953       {
10954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10955       };
10956     }
10957   }
10958
10959   jresult = (void *)result;
10960   return jresult;
10961 }
10962
10963
10964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10965   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10966
10967   arg1 = (Dali::Quaternion *)jarg1;
10968   {
10969     try {
10970       delete arg1;
10971     } catch (std::out_of_range& e) {
10972       {
10973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10974       };
10975     } catch (std::exception& e) {
10976       {
10977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10978       };
10979     } catch (Dali::DaliException e) {
10980       {
10981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10982       };
10983     } catch (...) {
10984       {
10985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10986       };
10987     }
10988   }
10989
10990 }
10991
10992
10993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10994   void * jresult ;
10995   Dali::Quaternion *result = 0 ;
10996
10997   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
10998   jresult = (void *)result;
10999   return jresult;
11000 }
11001
11002
11003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11004   unsigned int jresult ;
11005   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11006   bool result;
11007
11008   arg1 = (Dali::Quaternion *)jarg1;
11009   {
11010     try {
11011       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11012     } catch (std::out_of_range& e) {
11013       {
11014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11015       };
11016     } catch (std::exception& e) {
11017       {
11018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11019       };
11020     } catch (Dali::DaliException e) {
11021       {
11022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11023       };
11024     } catch (...) {
11025       {
11026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11027       };
11028     }
11029   }
11030
11031   jresult = result;
11032   return jresult;
11033 }
11034
11035
11036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11037   unsigned int jresult ;
11038   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11039   Dali::Vector3 *arg2 = 0 ;
11040   Dali::Radian *arg3 = 0 ;
11041   bool result;
11042
11043   arg1 = (Dali::Quaternion *)jarg1;
11044   arg2 = (Dali::Vector3 *)jarg2;
11045   if (!arg2) {
11046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11047     return 0;
11048   }
11049   arg3 = (Dali::Radian *)jarg3;
11050   if (!arg3) {
11051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11052     return 0;
11053   }
11054   {
11055     try {
11056       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11057     } catch (std::out_of_range& e) {
11058       {
11059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11060       };
11061     } catch (std::exception& e) {
11062       {
11063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11064       };
11065     } catch (Dali::DaliException e) {
11066       {
11067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11068       };
11069     } catch (...) {
11070       {
11071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11072       };
11073     }
11074   }
11075
11076   jresult = result;
11077   return jresult;
11078 }
11079
11080
11081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11082   void * jresult ;
11083   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11084   Dali::Quaternion *arg2 = 0 ;
11085   Dali::Quaternion result;
11086
11087   arg1 = (Dali::Quaternion *)jarg1;
11088   arg2 = (Dali::Quaternion *)jarg2;
11089   if (!arg2) {
11090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11091     return 0;
11092   }
11093   {
11094     try {
11095       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11096     } catch (std::out_of_range& e) {
11097       {
11098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11099       };
11100     } catch (std::exception& e) {
11101       {
11102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11103       };
11104     } catch (Dali::DaliException e) {
11105       {
11106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11107       };
11108     } catch (...) {
11109       {
11110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11111       };
11112     }
11113   }
11114
11115   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11116   return jresult;
11117 }
11118
11119
11120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11121   void * jresult ;
11122   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11123   Dali::Quaternion *arg2 = 0 ;
11124   Dali::Quaternion result;
11125
11126   arg1 = (Dali::Quaternion *)jarg1;
11127   arg2 = (Dali::Quaternion *)jarg2;
11128   if (!arg2) {
11129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11130     return 0;
11131   }
11132   {
11133     try {
11134       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11135     } catch (std::out_of_range& e) {
11136       {
11137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11138       };
11139     } catch (std::exception& e) {
11140       {
11141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11142       };
11143     } catch (Dali::DaliException e) {
11144       {
11145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11146       };
11147     } catch (...) {
11148       {
11149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11150       };
11151     }
11152   }
11153
11154   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11155   return jresult;
11156 }
11157
11158
11159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11160   void * jresult ;
11161   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11162   Dali::Quaternion *arg2 = 0 ;
11163   Dali::Quaternion result;
11164
11165   arg1 = (Dali::Quaternion *)jarg1;
11166   arg2 = (Dali::Quaternion *)jarg2;
11167   if (!arg2) {
11168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11169     return 0;
11170   }
11171   {
11172     try {
11173       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11174     } catch (std::out_of_range& e) {
11175       {
11176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11177       };
11178     } catch (std::exception& e) {
11179       {
11180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11181       };
11182     } catch (Dali::DaliException e) {
11183       {
11184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11185       };
11186     } catch (...) {
11187       {
11188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11189       };
11190     }
11191   }
11192
11193   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11194   return jresult;
11195 }
11196
11197
11198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11199   void * jresult ;
11200   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11201   Dali::Vector3 *arg2 = 0 ;
11202   Dali::Vector3 result;
11203
11204   arg1 = (Dali::Quaternion *)jarg1;
11205   arg2 = (Dali::Vector3 *)jarg2;
11206   if (!arg2) {
11207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11208     return 0;
11209   }
11210   {
11211     try {
11212       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11213     } catch (std::out_of_range& e) {
11214       {
11215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11216       };
11217     } catch (std::exception& e) {
11218       {
11219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11220       };
11221     } catch (Dali::DaliException e) {
11222       {
11223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11224       };
11225     } catch (...) {
11226       {
11227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11228       };
11229     }
11230   }
11231
11232   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11233   return jresult;
11234 }
11235
11236
11237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11238   void * jresult ;
11239   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11240   Dali::Quaternion *arg2 = 0 ;
11241   Dali::Quaternion result;
11242
11243   arg1 = (Dali::Quaternion *)jarg1;
11244   arg2 = (Dali::Quaternion *)jarg2;
11245   if (!arg2) {
11246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11247     return 0;
11248   }
11249   {
11250     try {
11251       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11252     } catch (std::out_of_range& e) {
11253       {
11254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11255       };
11256     } catch (std::exception& e) {
11257       {
11258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11259       };
11260     } catch (Dali::DaliException e) {
11261       {
11262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11263       };
11264     } catch (...) {
11265       {
11266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11267       };
11268     }
11269   }
11270
11271   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11272   return jresult;
11273 }
11274
11275
11276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11277   void * jresult ;
11278   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11279   float arg2 ;
11280   Dali::Quaternion result;
11281
11282   arg1 = (Dali::Quaternion *)jarg1;
11283   arg2 = (float)jarg2;
11284   {
11285     try {
11286       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11287     } catch (std::out_of_range& e) {
11288       {
11289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11290       };
11291     } catch (std::exception& e) {
11292       {
11293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11294       };
11295     } catch (Dali::DaliException e) {
11296       {
11297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11298       };
11299     } catch (...) {
11300       {
11301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11302       };
11303     }
11304   }
11305
11306   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11307   return jresult;
11308 }
11309
11310
11311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11312   void * jresult ;
11313   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11314   float arg2 ;
11315   Dali::Quaternion result;
11316
11317   arg1 = (Dali::Quaternion *)jarg1;
11318   arg2 = (float)jarg2;
11319   {
11320     try {
11321       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11322     } catch (std::out_of_range& e) {
11323       {
11324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11325       };
11326     } catch (std::exception& e) {
11327       {
11328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11329       };
11330     } catch (Dali::DaliException e) {
11331       {
11332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11333       };
11334     } catch (...) {
11335       {
11336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11337       };
11338     }
11339   }
11340
11341   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11342   return jresult;
11343 }
11344
11345
11346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11347   void * jresult ;
11348   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11349   Dali::Quaternion result;
11350
11351   arg1 = (Dali::Quaternion *)jarg1;
11352   {
11353     try {
11354       result = ((Dali::Quaternion const *)arg1)->operator -();
11355     } catch (std::out_of_range& e) {
11356       {
11357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11358       };
11359     } catch (std::exception& e) {
11360       {
11361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11362       };
11363     } catch (Dali::DaliException e) {
11364       {
11365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11366       };
11367     } catch (...) {
11368       {
11369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11370       };
11371     }
11372   }
11373
11374   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11375   return jresult;
11376 }
11377
11378
11379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11380   void * jresult ;
11381   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11382   Dali::Quaternion *arg2 = 0 ;
11383   Dali::Quaternion *result = 0 ;
11384
11385   arg1 = (Dali::Quaternion *)jarg1;
11386   arg2 = (Dali::Quaternion *)jarg2;
11387   if (!arg2) {
11388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11389     return 0;
11390   }
11391   {
11392     try {
11393       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11394     } catch (std::out_of_range& e) {
11395       {
11396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11397       };
11398     } catch (std::exception& e) {
11399       {
11400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11401       };
11402     } catch (Dali::DaliException e) {
11403       {
11404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11405       };
11406     } catch (...) {
11407       {
11408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11409       };
11410     }
11411   }
11412
11413   jresult = (void *)result;
11414   return jresult;
11415 }
11416
11417
11418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11419   void * jresult ;
11420   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11421   Dali::Quaternion *arg2 = 0 ;
11422   Dali::Quaternion *result = 0 ;
11423
11424   arg1 = (Dali::Quaternion *)jarg1;
11425   arg2 = (Dali::Quaternion *)jarg2;
11426   if (!arg2) {
11427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11428     return 0;
11429   }
11430   {
11431     try {
11432       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11433     } catch (std::out_of_range& e) {
11434       {
11435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11436       };
11437     } catch (std::exception& e) {
11438       {
11439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11440       };
11441     } catch (Dali::DaliException e) {
11442       {
11443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11444       };
11445     } catch (...) {
11446       {
11447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11448       };
11449     }
11450   }
11451
11452   jresult = (void *)result;
11453   return jresult;
11454 }
11455
11456
11457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11458   void * jresult ;
11459   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11460   Dali::Quaternion *arg2 = 0 ;
11461   Dali::Quaternion *result = 0 ;
11462
11463   arg1 = (Dali::Quaternion *)jarg1;
11464   arg2 = (Dali::Quaternion *)jarg2;
11465   if (!arg2) {
11466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11467     return 0;
11468   }
11469   {
11470     try {
11471       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11472     } catch (std::out_of_range& e) {
11473       {
11474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11475       };
11476     } catch (std::exception& e) {
11477       {
11478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11479       };
11480     } catch (Dali::DaliException e) {
11481       {
11482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11483       };
11484     } catch (...) {
11485       {
11486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11487       };
11488     }
11489   }
11490
11491   jresult = (void *)result;
11492   return jresult;
11493 }
11494
11495
11496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11497   void * jresult ;
11498   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11499   float arg2 ;
11500   Dali::Quaternion *result = 0 ;
11501
11502   arg1 = (Dali::Quaternion *)jarg1;
11503   arg2 = (float)jarg2;
11504   {
11505     try {
11506       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11507     } catch (std::out_of_range& e) {
11508       {
11509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11510       };
11511     } catch (std::exception& e) {
11512       {
11513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11514       };
11515     } catch (Dali::DaliException e) {
11516       {
11517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11518       };
11519     } catch (...) {
11520       {
11521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11522       };
11523     }
11524   }
11525
11526   jresult = (void *)result;
11527   return jresult;
11528 }
11529
11530
11531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11532   void * jresult ;
11533   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11534   float arg2 ;
11535   Dali::Quaternion *result = 0 ;
11536
11537   arg1 = (Dali::Quaternion *)jarg1;
11538   arg2 = (float)jarg2;
11539   {
11540     try {
11541       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11542     } catch (std::out_of_range& e) {
11543       {
11544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11545       };
11546     } catch (std::exception& e) {
11547       {
11548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11549       };
11550     } catch (Dali::DaliException e) {
11551       {
11552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11553       };
11554     } catch (...) {
11555       {
11556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11557       };
11558     }
11559   }
11560
11561   jresult = (void *)result;
11562   return jresult;
11563 }
11564
11565
11566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11567   unsigned int jresult ;
11568   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11569   Dali::Quaternion *arg2 = 0 ;
11570   bool result;
11571
11572   arg1 = (Dali::Quaternion *)jarg1;
11573   arg2 = (Dali::Quaternion *)jarg2;
11574   if (!arg2) {
11575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11576     return 0;
11577   }
11578   {
11579     try {
11580       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11581     } catch (std::out_of_range& e) {
11582       {
11583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11584       };
11585     } catch (std::exception& e) {
11586       {
11587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11588       };
11589     } catch (Dali::DaliException e) {
11590       {
11591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11592       };
11593     } catch (...) {
11594       {
11595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11596       };
11597     }
11598   }
11599
11600   jresult = result;
11601   return jresult;
11602 }
11603
11604
11605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11606   unsigned int jresult ;
11607   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11608   Dali::Quaternion *arg2 = 0 ;
11609   bool result;
11610
11611   arg1 = (Dali::Quaternion *)jarg1;
11612   arg2 = (Dali::Quaternion *)jarg2;
11613   if (!arg2) {
11614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11615     return 0;
11616   }
11617   {
11618     try {
11619       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11620     } catch (std::out_of_range& e) {
11621       {
11622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11623       };
11624     } catch (std::exception& e) {
11625       {
11626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11627       };
11628     } catch (Dali::DaliException e) {
11629       {
11630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11631       };
11632     } catch (...) {
11633       {
11634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11635       };
11636     }
11637   }
11638
11639   jresult = result;
11640   return jresult;
11641 }
11642
11643
11644 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11645   float jresult ;
11646   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11647   float result;
11648
11649   arg1 = (Dali::Quaternion *)jarg1;
11650   {
11651     try {
11652       result = (float)((Dali::Quaternion const *)arg1)->Length();
11653     } catch (std::out_of_range& e) {
11654       {
11655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11656       };
11657     } catch (std::exception& e) {
11658       {
11659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11660       };
11661     } catch (Dali::DaliException e) {
11662       {
11663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11664       };
11665     } catch (...) {
11666       {
11667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11668       };
11669     }
11670   }
11671
11672   jresult = result;
11673   return jresult;
11674 }
11675
11676
11677 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11678   float jresult ;
11679   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11680   float result;
11681
11682   arg1 = (Dali::Quaternion *)jarg1;
11683   {
11684     try {
11685       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11686     } catch (std::out_of_range& e) {
11687       {
11688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11689       };
11690     } catch (std::exception& e) {
11691       {
11692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11693       };
11694     } catch (Dali::DaliException e) {
11695       {
11696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11697       };
11698     } catch (...) {
11699       {
11700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11701       };
11702     }
11703   }
11704
11705   jresult = result;
11706   return jresult;
11707 }
11708
11709
11710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11711   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11712
11713   arg1 = (Dali::Quaternion *)jarg1;
11714   {
11715     try {
11716       (arg1)->Normalize();
11717     } catch (std::out_of_range& e) {
11718       {
11719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11720       };
11721     } catch (std::exception& e) {
11722       {
11723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11724       };
11725     } catch (Dali::DaliException e) {
11726       {
11727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11728       };
11729     } catch (...) {
11730       {
11731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11732       };
11733     }
11734   }
11735
11736 }
11737
11738
11739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11740   void * jresult ;
11741   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11742   Dali::Quaternion result;
11743
11744   arg1 = (Dali::Quaternion *)jarg1;
11745   {
11746     try {
11747       result = ((Dali::Quaternion const *)arg1)->Normalized();
11748     } catch (std::out_of_range& e) {
11749       {
11750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11751       };
11752     } catch (std::exception& e) {
11753       {
11754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11755       };
11756     } catch (Dali::DaliException e) {
11757       {
11758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11759       };
11760     } catch (...) {
11761       {
11762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11763       };
11764     }
11765   }
11766
11767   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11768   return jresult;
11769 }
11770
11771
11772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11773   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11774
11775   arg1 = (Dali::Quaternion *)jarg1;
11776   {
11777     try {
11778       (arg1)->Conjugate();
11779     } catch (std::out_of_range& e) {
11780       {
11781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11782       };
11783     } catch (std::exception& e) {
11784       {
11785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11786       };
11787     } catch (Dali::DaliException e) {
11788       {
11789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11790       };
11791     } catch (...) {
11792       {
11793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11794       };
11795     }
11796   }
11797
11798 }
11799
11800
11801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11802   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11803
11804   arg1 = (Dali::Quaternion *)jarg1;
11805   {
11806     try {
11807       (arg1)->Invert();
11808     } catch (std::out_of_range& e) {
11809       {
11810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11811       };
11812     } catch (std::exception& e) {
11813       {
11814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11815       };
11816     } catch (Dali::DaliException e) {
11817       {
11818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11819       };
11820     } catch (...) {
11821       {
11822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11823       };
11824     }
11825   }
11826
11827 }
11828
11829
11830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11831   void * jresult ;
11832   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11833   Dali::Quaternion result;
11834
11835   arg1 = (Dali::Quaternion *)jarg1;
11836   {
11837     try {
11838       result = ((Dali::Quaternion const *)arg1)->Log();
11839     } catch (std::out_of_range& e) {
11840       {
11841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11842       };
11843     } catch (std::exception& e) {
11844       {
11845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11846       };
11847     } catch (Dali::DaliException e) {
11848       {
11849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11850       };
11851     } catch (...) {
11852       {
11853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11854       };
11855     }
11856   }
11857
11858   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11859   return jresult;
11860 }
11861
11862
11863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11864   void * jresult ;
11865   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11866   Dali::Quaternion result;
11867
11868   arg1 = (Dali::Quaternion *)jarg1;
11869   {
11870     try {
11871       result = ((Dali::Quaternion const *)arg1)->Exp();
11872     } catch (std::out_of_range& e) {
11873       {
11874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11875       };
11876     } catch (std::exception& e) {
11877       {
11878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11879       };
11880     } catch (Dali::DaliException e) {
11881       {
11882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11883       };
11884     } catch (...) {
11885       {
11886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11887       };
11888     }
11889   }
11890
11891   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11892   return jresult;
11893 }
11894
11895
11896 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11897   float jresult ;
11898   Dali::Quaternion *arg1 = 0 ;
11899   Dali::Quaternion *arg2 = 0 ;
11900   float result;
11901
11902   arg1 = (Dali::Quaternion *)jarg1;
11903   if (!arg1) {
11904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11905     return 0;
11906   }
11907   arg2 = (Dali::Quaternion *)jarg2;
11908   if (!arg2) {
11909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11910     return 0;
11911   }
11912   {
11913     try {
11914       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11915     } catch (std::out_of_range& e) {
11916       {
11917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11918       };
11919     } catch (std::exception& e) {
11920       {
11921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11922       };
11923     } catch (Dali::DaliException e) {
11924       {
11925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11926       };
11927     } catch (...) {
11928       {
11929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11930       };
11931     }
11932   }
11933
11934   jresult = result;
11935   return jresult;
11936 }
11937
11938
11939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11940   void * jresult ;
11941   Dali::Quaternion *arg1 = 0 ;
11942   Dali::Quaternion *arg2 = 0 ;
11943   float arg3 ;
11944   Dali::Quaternion result;
11945
11946   arg1 = (Dali::Quaternion *)jarg1;
11947   if (!arg1) {
11948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11949     return 0;
11950   }
11951   arg2 = (Dali::Quaternion *)jarg2;
11952   if (!arg2) {
11953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11954     return 0;
11955   }
11956   arg3 = (float)jarg3;
11957   {
11958     try {
11959       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11960     } catch (std::out_of_range& e) {
11961       {
11962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11963       };
11964     } catch (std::exception& e) {
11965       {
11966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11967       };
11968     } catch (Dali::DaliException e) {
11969       {
11970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11971       };
11972     } catch (...) {
11973       {
11974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11975       };
11976     }
11977   }
11978
11979   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11980   return jresult;
11981 }
11982
11983
11984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11985   void * jresult ;
11986   Dali::Quaternion *arg1 = 0 ;
11987   Dali::Quaternion *arg2 = 0 ;
11988   float arg3 ;
11989   Dali::Quaternion result;
11990
11991   arg1 = (Dali::Quaternion *)jarg1;
11992   if (!arg1) {
11993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11994     return 0;
11995   }
11996   arg2 = (Dali::Quaternion *)jarg2;
11997   if (!arg2) {
11998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11999     return 0;
12000   }
12001   arg3 = (float)jarg3;
12002   {
12003     try {
12004       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12005     } catch (std::out_of_range& e) {
12006       {
12007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12008       };
12009     } catch (std::exception& e) {
12010       {
12011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12012       };
12013     } catch (Dali::DaliException e) {
12014       {
12015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12016       };
12017     } catch (...) {
12018       {
12019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12020       };
12021     }
12022   }
12023
12024   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12025   return jresult;
12026 }
12027
12028
12029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12030   void * jresult ;
12031   Dali::Quaternion *arg1 = 0 ;
12032   Dali::Quaternion *arg2 = 0 ;
12033   float arg3 ;
12034   Dali::Quaternion result;
12035
12036   arg1 = (Dali::Quaternion *)jarg1;
12037   if (!arg1) {
12038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12039     return 0;
12040   }
12041   arg2 = (Dali::Quaternion *)jarg2;
12042   if (!arg2) {
12043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12044     return 0;
12045   }
12046   arg3 = (float)jarg3;
12047   {
12048     try {
12049       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12050     } catch (std::out_of_range& e) {
12051       {
12052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12053       };
12054     } catch (std::exception& e) {
12055       {
12056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12057       };
12058     } catch (Dali::DaliException e) {
12059       {
12060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12061       };
12062     } catch (...) {
12063       {
12064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12065       };
12066     }
12067   }
12068
12069   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12070   return jresult;
12071 }
12072
12073
12074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12075   void * jresult ;
12076   Dali::Quaternion *arg1 = 0 ;
12077   Dali::Quaternion *arg2 = 0 ;
12078   Dali::Quaternion *arg3 = 0 ;
12079   Dali::Quaternion *arg4 = 0 ;
12080   float arg5 ;
12081   Dali::Quaternion result;
12082
12083   arg1 = (Dali::Quaternion *)jarg1;
12084   if (!arg1) {
12085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12086     return 0;
12087   }
12088   arg2 = (Dali::Quaternion *)jarg2;
12089   if (!arg2) {
12090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12091     return 0;
12092   }
12093   arg3 = (Dali::Quaternion *)jarg3;
12094   if (!arg3) {
12095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12096     return 0;
12097   }
12098   arg4 = (Dali::Quaternion *)jarg4;
12099   if (!arg4) {
12100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12101     return 0;
12102   }
12103   arg5 = (float)jarg5;
12104   {
12105     try {
12106       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12107     } catch (std::out_of_range& e) {
12108       {
12109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12110       };
12111     } catch (std::exception& e) {
12112       {
12113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12114       };
12115     } catch (Dali::DaliException e) {
12116       {
12117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12118       };
12119     } catch (...) {
12120       {
12121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12122       };
12123     }
12124   }
12125
12126   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12127   return jresult;
12128 }
12129
12130
12131 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12132   float jresult ;
12133   Dali::Quaternion *arg1 = 0 ;
12134   Dali::Quaternion *arg2 = 0 ;
12135   float result;
12136
12137   arg1 = (Dali::Quaternion *)jarg1;
12138   if (!arg1) {
12139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12140     return 0;
12141   }
12142   arg2 = (Dali::Quaternion *)jarg2;
12143   if (!arg2) {
12144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12145     return 0;
12146   }
12147   {
12148     try {
12149       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12150     } catch (std::out_of_range& e) {
12151       {
12152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12153       };
12154     } catch (std::exception& e) {
12155       {
12156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12157       };
12158     } catch (Dali::DaliException e) {
12159       {
12160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12161       };
12162     } catch (...) {
12163       {
12164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12165       };
12166     }
12167   }
12168
12169   jresult = result;
12170   return jresult;
12171 }
12172
12173
12174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12175   void * jresult ;
12176   Dali::Matrix *result = 0 ;
12177
12178   {
12179     try {
12180       result = (Dali::Matrix *)new Dali::Matrix();
12181     } catch (std::out_of_range& e) {
12182       {
12183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12184       };
12185     } catch (std::exception& e) {
12186       {
12187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12188       };
12189     } catch (Dali::DaliException e) {
12190       {
12191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12192       };
12193     } catch (...) {
12194       {
12195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12196       };
12197     }
12198   }
12199
12200   jresult = (void *)result;
12201   return jresult;
12202 }
12203
12204
12205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12206   void * jresult ;
12207   bool arg1 ;
12208   Dali::Matrix *result = 0 ;
12209
12210   arg1 = jarg1 ? true : false;
12211   {
12212     try {
12213       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12214     } catch (std::out_of_range& e) {
12215       {
12216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12217       };
12218     } catch (std::exception& e) {
12219       {
12220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12221       };
12222     } catch (Dali::DaliException e) {
12223       {
12224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12225       };
12226     } catch (...) {
12227       {
12228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12229       };
12230     }
12231   }
12232
12233   jresult = (void *)result;
12234   return jresult;
12235 }
12236
12237
12238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12239   void * jresult ;
12240   float *arg1 = (float *) 0 ;
12241   Dali::Matrix *result = 0 ;
12242
12243   arg1 = jarg1;
12244   {
12245     try {
12246       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12247     } catch (std::out_of_range& e) {
12248       {
12249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12250       };
12251     } catch (std::exception& e) {
12252       {
12253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12254       };
12255     } catch (Dali::DaliException e) {
12256       {
12257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12258       };
12259     } catch (...) {
12260       {
12261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12262       };
12263     }
12264   }
12265
12266   jresult = (void *)result;
12267
12268
12269   return jresult;
12270 }
12271
12272
12273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12274   void * jresult ;
12275   Dali::Quaternion *arg1 = 0 ;
12276   Dali::Matrix *result = 0 ;
12277
12278   arg1 = (Dali::Quaternion *)jarg1;
12279   if (!arg1) {
12280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12281     return 0;
12282   }
12283   {
12284     try {
12285       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12286     } catch (std::out_of_range& e) {
12287       {
12288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12289       };
12290     } catch (std::exception& e) {
12291       {
12292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12293       };
12294     } catch (Dali::DaliException e) {
12295       {
12296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12297       };
12298     } catch (...) {
12299       {
12300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12301       };
12302     }
12303   }
12304
12305   jresult = (void *)result;
12306   return jresult;
12307 }
12308
12309
12310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12311   void * jresult ;
12312   Dali::Matrix *arg1 = 0 ;
12313   Dali::Matrix *result = 0 ;
12314
12315   arg1 = (Dali::Matrix *)jarg1;
12316   if (!arg1) {
12317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12318     return 0;
12319   }
12320   {
12321     try {
12322       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12323     } catch (std::out_of_range& e) {
12324       {
12325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12326       };
12327     } catch (std::exception& e) {
12328       {
12329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12330       };
12331     } catch (Dali::DaliException e) {
12332       {
12333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12334       };
12335     } catch (...) {
12336       {
12337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12338       };
12339     }
12340   }
12341
12342   jresult = (void *)result;
12343   return jresult;
12344 }
12345
12346
12347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12348   void * jresult ;
12349   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12350   Dali::Matrix *arg2 = 0 ;
12351   Dali::Matrix *result = 0 ;
12352
12353   arg1 = (Dali::Matrix *)jarg1;
12354   arg2 = (Dali::Matrix *)jarg2;
12355   if (!arg2) {
12356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12357     return 0;
12358   }
12359   {
12360     try {
12361       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12362     } catch (std::out_of_range& e) {
12363       {
12364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12365       };
12366     } catch (std::exception& e) {
12367       {
12368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12369       };
12370     } catch (Dali::DaliException e) {
12371       {
12372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12373       };
12374     } catch (...) {
12375       {
12376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12377       };
12378     }
12379   }
12380
12381   jresult = (void *)result;
12382   return jresult;
12383 }
12384
12385
12386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12387   void * jresult ;
12388   Dali::Matrix *result = 0 ;
12389
12390   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12391   jresult = (void *)result;
12392   return jresult;
12393 }
12394
12395
12396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12397   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12398
12399   arg1 = (Dali::Matrix *)jarg1;
12400   {
12401     try {
12402       (arg1)->SetIdentity();
12403     } catch (std::out_of_range& e) {
12404       {
12405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12406       };
12407     } catch (std::exception& e) {
12408       {
12409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12410       };
12411     } catch (Dali::DaliException e) {
12412       {
12413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12414       };
12415     } catch (...) {
12416       {
12417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12418       };
12419     }
12420   }
12421
12422 }
12423
12424
12425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12426   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12427   Dali::Vector3 *arg2 = 0 ;
12428
12429   arg1 = (Dali::Matrix *)jarg1;
12430   arg2 = (Dali::Vector3 *)jarg2;
12431   if (!arg2) {
12432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12433     return ;
12434   }
12435   {
12436     try {
12437       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12438     } catch (std::out_of_range& e) {
12439       {
12440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12441       };
12442     } catch (std::exception& e) {
12443       {
12444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12445       };
12446     } catch (Dali::DaliException e) {
12447       {
12448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12449       };
12450     } catch (...) {
12451       {
12452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12453       };
12454     }
12455   }
12456
12457 }
12458
12459
12460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12461   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12462   Dali::Matrix *arg2 = 0 ;
12463
12464   arg1 = (Dali::Matrix *)jarg1;
12465   arg2 = (Dali::Matrix *)jarg2;
12466   if (!arg2) {
12467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12468     return ;
12469   }
12470   {
12471     try {
12472       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12473     } catch (std::out_of_range& e) {
12474       {
12475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12476       };
12477     } catch (std::exception& e) {
12478       {
12479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12480       };
12481     } catch (Dali::DaliException e) {
12482       {
12483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12484       };
12485     } catch (...) {
12486       {
12487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12488       };
12489     }
12490   }
12491
12492 }
12493
12494
12495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12496   unsigned int jresult ;
12497   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12498   bool result;
12499
12500   arg1 = (Dali::Matrix *)jarg1;
12501   {
12502     try {
12503       result = (bool)(arg1)->Invert();
12504     } catch (std::out_of_range& e) {
12505       {
12506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12507       };
12508     } catch (std::exception& e) {
12509       {
12510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12511       };
12512     } catch (Dali::DaliException e) {
12513       {
12514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12515       };
12516     } catch (...) {
12517       {
12518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12519       };
12520     }
12521   }
12522
12523   jresult = result;
12524   return jresult;
12525 }
12526
12527
12528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12529   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12530
12531   arg1 = (Dali::Matrix *)jarg1;
12532   {
12533     try {
12534       (arg1)->Transpose();
12535     } catch (std::out_of_range& e) {
12536       {
12537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12538       };
12539     } catch (std::exception& e) {
12540       {
12541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12542       };
12543     } catch (Dali::DaliException e) {
12544       {
12545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12546       };
12547     } catch (...) {
12548       {
12549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12550       };
12551     }
12552   }
12553
12554 }
12555
12556
12557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12558   void * jresult ;
12559   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12560   Dali::Vector3 result;
12561
12562   arg1 = (Dali::Matrix *)jarg1;
12563   {
12564     try {
12565       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12566     } catch (std::out_of_range& e) {
12567       {
12568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12569       };
12570     } catch (std::exception& e) {
12571       {
12572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12573       };
12574     } catch (Dali::DaliException e) {
12575       {
12576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12577       };
12578     } catch (...) {
12579       {
12580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12581       };
12582     }
12583   }
12584
12585   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12586   return jresult;
12587 }
12588
12589
12590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12591   void * jresult ;
12592   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12593   Dali::Vector3 result;
12594
12595   arg1 = (Dali::Matrix *)jarg1;
12596   {
12597     try {
12598       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12599     } catch (std::out_of_range& e) {
12600       {
12601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12602       };
12603     } catch (std::exception& e) {
12604       {
12605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12606       };
12607     } catch (Dali::DaliException e) {
12608       {
12609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12610       };
12611     } catch (...) {
12612       {
12613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12614       };
12615     }
12616   }
12617
12618   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12619   return jresult;
12620 }
12621
12622
12623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12624   void * jresult ;
12625   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12626   Dali::Vector3 result;
12627
12628   arg1 = (Dali::Matrix *)jarg1;
12629   {
12630     try {
12631       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12632     } catch (std::out_of_range& e) {
12633       {
12634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12635       };
12636     } catch (std::exception& e) {
12637       {
12638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12639       };
12640     } catch (Dali::DaliException e) {
12641       {
12642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12643       };
12644     } catch (...) {
12645       {
12646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12647       };
12648     }
12649   }
12650
12651   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12652   return jresult;
12653 }
12654
12655
12656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12657   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12658   Dali::Vector3 *arg2 = 0 ;
12659
12660   arg1 = (Dali::Matrix *)jarg1;
12661   arg2 = (Dali::Vector3 *)jarg2;
12662   if (!arg2) {
12663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12664     return ;
12665   }
12666   {
12667     try {
12668       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12669     } catch (std::out_of_range& e) {
12670       {
12671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12672       };
12673     } catch (std::exception& e) {
12674       {
12675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12676       };
12677     } catch (Dali::DaliException e) {
12678       {
12679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12680       };
12681     } catch (...) {
12682       {
12683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12684       };
12685     }
12686   }
12687
12688 }
12689
12690
12691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12692   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12693   Dali::Vector3 *arg2 = 0 ;
12694
12695   arg1 = (Dali::Matrix *)jarg1;
12696   arg2 = (Dali::Vector3 *)jarg2;
12697   if (!arg2) {
12698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12699     return ;
12700   }
12701   {
12702     try {
12703       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12704     } catch (std::out_of_range& e) {
12705       {
12706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12707       };
12708     } catch (std::exception& e) {
12709       {
12710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12711       };
12712     } catch (Dali::DaliException e) {
12713       {
12714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12715       };
12716     } catch (...) {
12717       {
12718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12719       };
12720     }
12721   }
12722
12723 }
12724
12725
12726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12727   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12728   Dali::Vector3 *arg2 = 0 ;
12729
12730   arg1 = (Dali::Matrix *)jarg1;
12731   arg2 = (Dali::Vector3 *)jarg2;
12732   if (!arg2) {
12733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12734     return ;
12735   }
12736   {
12737     try {
12738       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12739     } catch (std::out_of_range& e) {
12740       {
12741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12742       };
12743     } catch (std::exception& e) {
12744       {
12745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12746       };
12747     } catch (Dali::DaliException e) {
12748       {
12749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12750       };
12751     } catch (...) {
12752       {
12753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12754       };
12755     }
12756   }
12757
12758 }
12759
12760
12761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12762   void * jresult ;
12763   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12764   Dali::Vector4 *result = 0 ;
12765
12766   arg1 = (Dali::Matrix *)jarg1;
12767   {
12768     try {
12769       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12770     } catch (std::out_of_range& e) {
12771       {
12772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12773       };
12774     } catch (std::exception& e) {
12775       {
12776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12777       };
12778     } catch (Dali::DaliException e) {
12779       {
12780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12781       };
12782     } catch (...) {
12783       {
12784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12785       };
12786     }
12787   }
12788
12789   jresult = (void *)result;
12790   return jresult;
12791 }
12792
12793
12794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12795   void * jresult ;
12796   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12797   Dali::Vector3 *result = 0 ;
12798
12799   arg1 = (Dali::Matrix *)jarg1;
12800   {
12801     try {
12802       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12803     } catch (std::out_of_range& e) {
12804       {
12805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12806       };
12807     } catch (std::exception& e) {
12808       {
12809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12810       };
12811     } catch (Dali::DaliException e) {
12812       {
12813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12814       };
12815     } catch (...) {
12816       {
12817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12818       };
12819     }
12820   }
12821
12822   jresult = (void *)result;
12823   return jresult;
12824 }
12825
12826
12827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12828   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12829   Dali::Vector4 *arg2 = 0 ;
12830
12831   arg1 = (Dali::Matrix *)jarg1;
12832   arg2 = (Dali::Vector4 *)jarg2;
12833   if (!arg2) {
12834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12835     return ;
12836   }
12837   {
12838     try {
12839       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12840     } catch (std::out_of_range& e) {
12841       {
12842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12843       };
12844     } catch (std::exception& e) {
12845       {
12846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12847       };
12848     } catch (Dali::DaliException e) {
12849       {
12850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12851       };
12852     } catch (...) {
12853       {
12854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12855       };
12856     }
12857   }
12858
12859 }
12860
12861
12862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12863   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12864   Dali::Vector3 *arg2 = 0 ;
12865
12866   arg1 = (Dali::Matrix *)jarg1;
12867   arg2 = (Dali::Vector3 *)jarg2;
12868   if (!arg2) {
12869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12870     return ;
12871   }
12872   {
12873     try {
12874       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12875     } catch (std::out_of_range& e) {
12876       {
12877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12878       };
12879     } catch (std::exception& e) {
12880       {
12881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12882       };
12883     } catch (Dali::DaliException e) {
12884       {
12885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12886       };
12887     } catch (...) {
12888       {
12889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12890       };
12891     }
12892   }
12893
12894 }
12895
12896
12897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12898   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12899
12900   arg1 = (Dali::Matrix *)jarg1;
12901   {
12902     try {
12903       (arg1)->OrthoNormalize();
12904     } catch (std::out_of_range& e) {
12905       {
12906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12907       };
12908     } catch (std::exception& e) {
12909       {
12910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12911       };
12912     } catch (Dali::DaliException e) {
12913       {
12914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12915       };
12916     } catch (...) {
12917       {
12918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12919       };
12920     }
12921   }
12922
12923 }
12924
12925
12926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12927   void * jresult ;
12928   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12929   float *result = 0 ;
12930
12931   arg1 = (Dali::Matrix *)jarg1;
12932   {
12933     try {
12934       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12935     } catch (std::out_of_range& e) {
12936       {
12937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12938       };
12939     } catch (std::exception& e) {
12940       {
12941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12942       };
12943     } catch (Dali::DaliException e) {
12944       {
12945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12946       };
12947     } catch (...) {
12948       {
12949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12950       };
12951     }
12952   }
12953
12954   jresult = (void *)result;
12955   return jresult;
12956 }
12957
12958
12959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12960   Dali::Matrix *arg1 = 0 ;
12961   Dali::Matrix *arg2 = 0 ;
12962   Dali::Matrix *arg3 = 0 ;
12963
12964   arg1 = (Dali::Matrix *)jarg1;
12965   if (!arg1) {
12966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12967     return ;
12968   }
12969   arg2 = (Dali::Matrix *)jarg2;
12970   if (!arg2) {
12971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12972     return ;
12973   }
12974   arg3 = (Dali::Matrix *)jarg3;
12975   if (!arg3) {
12976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12977     return ;
12978   }
12979   {
12980     try {
12981       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12982     } catch (std::out_of_range& e) {
12983       {
12984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12985       };
12986     } catch (std::exception& e) {
12987       {
12988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12989       };
12990     } catch (Dali::DaliException e) {
12991       {
12992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12993       };
12994     } catch (...) {
12995       {
12996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12997       };
12998     }
12999   }
13000
13001 }
13002
13003
13004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13005   Dali::Matrix *arg1 = 0 ;
13006   Dali::Matrix *arg2 = 0 ;
13007   Dali::Quaternion *arg3 = 0 ;
13008
13009   arg1 = (Dali::Matrix *)jarg1;
13010   if (!arg1) {
13011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13012     return ;
13013   }
13014   arg2 = (Dali::Matrix *)jarg2;
13015   if (!arg2) {
13016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13017     return ;
13018   }
13019   arg3 = (Dali::Quaternion *)jarg3;
13020   if (!arg3) {
13021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13022     return ;
13023   }
13024   {
13025     try {
13026       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13027     } catch (std::out_of_range& e) {
13028       {
13029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13030       };
13031     } catch (std::exception& e) {
13032       {
13033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13034       };
13035     } catch (Dali::DaliException e) {
13036       {
13037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13038       };
13039     } catch (...) {
13040       {
13041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13042       };
13043     }
13044   }
13045
13046 }
13047
13048
13049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13050   void * jresult ;
13051   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13052   Dali::Vector4 *arg2 = 0 ;
13053   Dali::Vector4 result;
13054
13055   arg1 = (Dali::Matrix *)jarg1;
13056   arg2 = (Dali::Vector4 *)jarg2;
13057   if (!arg2) {
13058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13059     return 0;
13060   }
13061   {
13062     try {
13063       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13064     } catch (std::out_of_range& e) {
13065       {
13066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13067       };
13068     } catch (std::exception& e) {
13069       {
13070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13071       };
13072     } catch (Dali::DaliException e) {
13073       {
13074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13075       };
13076     } catch (...) {
13077       {
13078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13079       };
13080     }
13081   }
13082
13083   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13084   return jresult;
13085 }
13086
13087
13088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13089   unsigned int jresult ;
13090   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13091   Dali::Matrix *arg2 = 0 ;
13092   bool result;
13093
13094   arg1 = (Dali::Matrix *)jarg1;
13095   arg2 = (Dali::Matrix *)jarg2;
13096   if (!arg2) {
13097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13098     return 0;
13099   }
13100   {
13101     try {
13102       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13103     } catch (std::out_of_range& e) {
13104       {
13105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13106       };
13107     } catch (std::exception& e) {
13108       {
13109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13110       };
13111     } catch (Dali::DaliException e) {
13112       {
13113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13114       };
13115     } catch (...) {
13116       {
13117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13118       };
13119     }
13120   }
13121
13122   jresult = result;
13123   return jresult;
13124 }
13125
13126
13127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13128   unsigned int jresult ;
13129   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13130   Dali::Matrix *arg2 = 0 ;
13131   bool result;
13132
13133   arg1 = (Dali::Matrix *)jarg1;
13134   arg2 = (Dali::Matrix *)jarg2;
13135   if (!arg2) {
13136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13137     return 0;
13138   }
13139   {
13140     try {
13141       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13142     } catch (std::out_of_range& e) {
13143       {
13144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13145       };
13146     } catch (std::exception& e) {
13147       {
13148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13149       };
13150     } catch (Dali::DaliException e) {
13151       {
13152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13153       };
13154     } catch (...) {
13155       {
13156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13157       };
13158     }
13159   }
13160
13161   jresult = result;
13162   return jresult;
13163 }
13164
13165
13166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13167   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13168   Dali::Vector3 *arg2 = 0 ;
13169   Dali::Quaternion *arg3 = 0 ;
13170   Dali::Vector3 *arg4 = 0 ;
13171
13172   arg1 = (Dali::Matrix *)jarg1;
13173   arg2 = (Dali::Vector3 *)jarg2;
13174   if (!arg2) {
13175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13176     return ;
13177   }
13178   arg3 = (Dali::Quaternion *)jarg3;
13179   if (!arg3) {
13180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13181     return ;
13182   }
13183   arg4 = (Dali::Vector3 *)jarg4;
13184   if (!arg4) {
13185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13186     return ;
13187   }
13188   {
13189     try {
13190       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13191     } catch (std::out_of_range& e) {
13192       {
13193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13194       };
13195     } catch (std::exception& e) {
13196       {
13197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13198       };
13199     } catch (Dali::DaliException e) {
13200       {
13201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13202       };
13203     } catch (...) {
13204       {
13205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13206       };
13207     }
13208   }
13209
13210 }
13211
13212
13213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13214   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13215   Dali::Vector3 *arg2 = 0 ;
13216   Dali::Quaternion *arg3 = 0 ;
13217   Dali::Vector3 *arg4 = 0 ;
13218
13219   arg1 = (Dali::Matrix *)jarg1;
13220   arg2 = (Dali::Vector3 *)jarg2;
13221   if (!arg2) {
13222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13223     return ;
13224   }
13225   arg3 = (Dali::Quaternion *)jarg3;
13226   if (!arg3) {
13227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13228     return ;
13229   }
13230   arg4 = (Dali::Vector3 *)jarg4;
13231   if (!arg4) {
13232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13233     return ;
13234   }
13235   {
13236     try {
13237       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13238     } catch (std::out_of_range& e) {
13239       {
13240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13241       };
13242     } catch (std::exception& e) {
13243       {
13244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13245       };
13246     } catch (Dali::DaliException e) {
13247       {
13248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13249       };
13250     } catch (...) {
13251       {
13252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13253       };
13254     }
13255   }
13256
13257 }
13258
13259
13260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13261   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13262   Dali::Vector3 *arg2 = 0 ;
13263   Dali::Vector3 *arg3 = 0 ;
13264   Dali::Vector3 *arg4 = 0 ;
13265   Dali::Vector3 *arg5 = 0 ;
13266
13267   arg1 = (Dali::Matrix *)jarg1;
13268   arg2 = (Dali::Vector3 *)jarg2;
13269   if (!arg2) {
13270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13271     return ;
13272   }
13273   arg3 = (Dali::Vector3 *)jarg3;
13274   if (!arg3) {
13275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13276     return ;
13277   }
13278   arg4 = (Dali::Vector3 *)jarg4;
13279   if (!arg4) {
13280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13281     return ;
13282   }
13283   arg5 = (Dali::Vector3 *)jarg5;
13284   if (!arg5) {
13285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13286     return ;
13287   }
13288   {
13289     try {
13290       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13291     } catch (std::out_of_range& e) {
13292       {
13293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13294       };
13295     } catch (std::exception& e) {
13296       {
13297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13298       };
13299     } catch (Dali::DaliException e) {
13300       {
13301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13302       };
13303     } catch (...) {
13304       {
13305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13306       };
13307     }
13308   }
13309
13310 }
13311
13312
13313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13314   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13315   Dali::Vector3 *arg2 = 0 ;
13316   Dali::Quaternion *arg3 = 0 ;
13317   Dali::Vector3 *arg4 = 0 ;
13318
13319   arg1 = (Dali::Matrix *)jarg1;
13320   arg2 = (Dali::Vector3 *)jarg2;
13321   if (!arg2) {
13322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13323     return ;
13324   }
13325   arg3 = (Dali::Quaternion *)jarg3;
13326   if (!arg3) {
13327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13328     return ;
13329   }
13330   arg4 = (Dali::Vector3 *)jarg4;
13331   if (!arg4) {
13332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13333     return ;
13334   }
13335   {
13336     try {
13337       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13338     } catch (std::out_of_range& e) {
13339       {
13340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13341       };
13342     } catch (std::exception& e) {
13343       {
13344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13345       };
13346     } catch (Dali::DaliException e) {
13347       {
13348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13349       };
13350     } catch (...) {
13351       {
13352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13353       };
13354     }
13355   }
13356
13357 }
13358
13359
13360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13361   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13362
13363   arg1 = (Dali::Matrix *)jarg1;
13364   {
13365     try {
13366       delete arg1;
13367     } catch (std::out_of_range& e) {
13368       {
13369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13370       };
13371     } catch (std::exception& e) {
13372       {
13373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13374       };
13375     } catch (Dali::DaliException e) {
13376       {
13377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13378       };
13379     } catch (...) {
13380       {
13381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13382       };
13383     }
13384   }
13385
13386 }
13387
13388
13389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13390   void * jresult ;
13391   Dali::Matrix3 *result = 0 ;
13392
13393   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13394   jresult = (void *)result;
13395   return jresult;
13396 }
13397
13398
13399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13400   void * jresult ;
13401   Dali::Matrix3 *result = 0 ;
13402
13403   {
13404     try {
13405       result = (Dali::Matrix3 *)new Dali::Matrix3();
13406     } catch (std::out_of_range& e) {
13407       {
13408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13409       };
13410     } catch (std::exception& e) {
13411       {
13412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13413       };
13414     } catch (Dali::DaliException e) {
13415       {
13416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13417       };
13418     } catch (...) {
13419       {
13420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13421       };
13422     }
13423   }
13424
13425   jresult = (void *)result;
13426   return jresult;
13427 }
13428
13429
13430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13431   void * jresult ;
13432   Dali::Matrix3 *arg1 = 0 ;
13433   Dali::Matrix3 *result = 0 ;
13434
13435   arg1 = (Dali::Matrix3 *)jarg1;
13436   if (!arg1) {
13437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13438     return 0;
13439   }
13440   {
13441     try {
13442       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13443     } catch (std::out_of_range& e) {
13444       {
13445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13446       };
13447     } catch (std::exception& e) {
13448       {
13449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13450       };
13451     } catch (Dali::DaliException e) {
13452       {
13453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13454       };
13455     } catch (...) {
13456       {
13457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13458       };
13459     }
13460   }
13461
13462   jresult = (void *)result;
13463   return jresult;
13464 }
13465
13466
13467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13468   void * jresult ;
13469   Dali::Matrix *arg1 = 0 ;
13470   Dali::Matrix3 *result = 0 ;
13471
13472   arg1 = (Dali::Matrix *)jarg1;
13473   if (!arg1) {
13474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13475     return 0;
13476   }
13477   {
13478     try {
13479       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13480     } catch (std::out_of_range& e) {
13481       {
13482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13483       };
13484     } catch (std::exception& e) {
13485       {
13486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13487       };
13488     } catch (Dali::DaliException e) {
13489       {
13490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13491       };
13492     } catch (...) {
13493       {
13494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13495       };
13496     }
13497   }
13498
13499   jresult = (void *)result;
13500   return jresult;
13501 }
13502
13503
13504 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) {
13505   void * jresult ;
13506   float arg1 ;
13507   float arg2 ;
13508   float arg3 ;
13509   float arg4 ;
13510   float arg5 ;
13511   float arg6 ;
13512   float arg7 ;
13513   float arg8 ;
13514   float arg9 ;
13515   Dali::Matrix3 *result = 0 ;
13516
13517   arg1 = (float)jarg1;
13518   arg2 = (float)jarg2;
13519   arg3 = (float)jarg3;
13520   arg4 = (float)jarg4;
13521   arg5 = (float)jarg5;
13522   arg6 = (float)jarg6;
13523   arg7 = (float)jarg7;
13524   arg8 = (float)jarg8;
13525   arg9 = (float)jarg9;
13526   {
13527     try {
13528       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13529     } catch (std::out_of_range& e) {
13530       {
13531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13532       };
13533     } catch (std::exception& e) {
13534       {
13535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13536       };
13537     } catch (Dali::DaliException e) {
13538       {
13539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13540       };
13541     } catch (...) {
13542       {
13543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13544       };
13545     }
13546   }
13547
13548   jresult = (void *)result;
13549   return jresult;
13550 }
13551
13552
13553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13554   void * jresult ;
13555   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13556   Dali::Matrix3 *arg2 = 0 ;
13557   Dali::Matrix3 *result = 0 ;
13558
13559   arg1 = (Dali::Matrix3 *)jarg1;
13560   arg2 = (Dali::Matrix3 *)jarg2;
13561   if (!arg2) {
13562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13563     return 0;
13564   }
13565   {
13566     try {
13567       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13568     } catch (std::out_of_range& e) {
13569       {
13570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13571       };
13572     } catch (std::exception& e) {
13573       {
13574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13575       };
13576     } catch (Dali::DaliException e) {
13577       {
13578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13579       };
13580     } catch (...) {
13581       {
13582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13583       };
13584     }
13585   }
13586
13587   jresult = (void *)result;
13588   return jresult;
13589 }
13590
13591
13592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13593   void * jresult ;
13594   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13595   Dali::Matrix *arg2 = 0 ;
13596   Dali::Matrix3 *result = 0 ;
13597
13598   arg1 = (Dali::Matrix3 *)jarg1;
13599   arg2 = (Dali::Matrix *)jarg2;
13600   if (!arg2) {
13601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13602     return 0;
13603   }
13604   {
13605     try {
13606       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13607     } catch (std::out_of_range& e) {
13608       {
13609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13610       };
13611     } catch (std::exception& e) {
13612       {
13613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13614       };
13615     } catch (Dali::DaliException e) {
13616       {
13617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13618       };
13619     } catch (...) {
13620       {
13621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13622       };
13623     }
13624   }
13625
13626   jresult = (void *)result;
13627   return jresult;
13628 }
13629
13630
13631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13632   unsigned int jresult ;
13633   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13634   Dali::Matrix3 *arg2 = 0 ;
13635   bool result;
13636
13637   arg1 = (Dali::Matrix3 *)jarg1;
13638   arg2 = (Dali::Matrix3 *)jarg2;
13639   if (!arg2) {
13640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13641     return 0;
13642   }
13643   {
13644     try {
13645       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13646     } catch (std::out_of_range& e) {
13647       {
13648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13649       };
13650     } catch (std::exception& e) {
13651       {
13652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13653       };
13654     } catch (Dali::DaliException e) {
13655       {
13656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13657       };
13658     } catch (...) {
13659       {
13660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13661       };
13662     }
13663   }
13664
13665   jresult = result;
13666   return jresult;
13667 }
13668
13669
13670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13671   unsigned int jresult ;
13672   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13673   Dali::Matrix3 *arg2 = 0 ;
13674   bool result;
13675
13676   arg1 = (Dali::Matrix3 *)jarg1;
13677   arg2 = (Dali::Matrix3 *)jarg2;
13678   if (!arg2) {
13679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13680     return 0;
13681   }
13682   {
13683     try {
13684       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13685     } catch (std::out_of_range& e) {
13686       {
13687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13688       };
13689     } catch (std::exception& e) {
13690       {
13691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13692       };
13693     } catch (Dali::DaliException e) {
13694       {
13695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13696       };
13697     } catch (...) {
13698       {
13699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13700       };
13701     }
13702   }
13703
13704   jresult = result;
13705   return jresult;
13706 }
13707
13708
13709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13710   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13711
13712   arg1 = (Dali::Matrix3 *)jarg1;
13713   {
13714     try {
13715       delete arg1;
13716     } catch (std::out_of_range& e) {
13717       {
13718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13719       };
13720     } catch (std::exception& e) {
13721       {
13722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13723       };
13724     } catch (Dali::DaliException e) {
13725       {
13726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13727       };
13728     } catch (...) {
13729       {
13730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13731       };
13732     }
13733   }
13734
13735 }
13736
13737
13738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13739   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13740
13741   arg1 = (Dali::Matrix3 *)jarg1;
13742   {
13743     try {
13744       (arg1)->SetIdentity();
13745     } catch (std::out_of_range& e) {
13746       {
13747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13748       };
13749     } catch (std::exception& e) {
13750       {
13751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13752       };
13753     } catch (Dali::DaliException e) {
13754       {
13755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13756       };
13757     } catch (...) {
13758       {
13759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13760       };
13761     }
13762   }
13763
13764 }
13765
13766
13767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13768   void * jresult ;
13769   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13770   float *result = 0 ;
13771
13772   arg1 = (Dali::Matrix3 *)jarg1;
13773   {
13774     try {
13775       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13776     } catch (std::out_of_range& e) {
13777       {
13778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13779       };
13780     } catch (std::exception& e) {
13781       {
13782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13783       };
13784     } catch (Dali::DaliException e) {
13785       {
13786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13787       };
13788     } catch (...) {
13789       {
13790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13791       };
13792     }
13793   }
13794
13795   jresult = (void *)result;
13796   return jresult;
13797 }
13798
13799
13800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13801   unsigned int jresult ;
13802   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13803   bool result;
13804
13805   arg1 = (Dali::Matrix3 *)jarg1;
13806   {
13807     try {
13808       result = (bool)(arg1)->Invert();
13809     } catch (std::out_of_range& e) {
13810       {
13811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13812       };
13813     } catch (std::exception& e) {
13814       {
13815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13816       };
13817     } catch (Dali::DaliException e) {
13818       {
13819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13820       };
13821     } catch (...) {
13822       {
13823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13824       };
13825     }
13826   }
13827
13828   jresult = result;
13829   return jresult;
13830 }
13831
13832
13833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13834   unsigned int jresult ;
13835   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13836   bool result;
13837
13838   arg1 = (Dali::Matrix3 *)jarg1;
13839   {
13840     try {
13841       result = (bool)(arg1)->Transpose();
13842     } catch (std::out_of_range& e) {
13843       {
13844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13845       };
13846     } catch (std::exception& e) {
13847       {
13848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13849       };
13850     } catch (Dali::DaliException e) {
13851       {
13852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13853       };
13854     } catch (...) {
13855       {
13856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13857       };
13858     }
13859   }
13860
13861   jresult = result;
13862   return jresult;
13863 }
13864
13865
13866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13867   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13868   float arg2 ;
13869
13870   arg1 = (Dali::Matrix3 *)jarg1;
13871   arg2 = (float)jarg2;
13872   {
13873     try {
13874       (arg1)->Scale(arg2);
13875     } catch (std::out_of_range& e) {
13876       {
13877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13878       };
13879     } catch (std::exception& e) {
13880       {
13881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13882       };
13883     } catch (Dali::DaliException e) {
13884       {
13885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13886       };
13887     } catch (...) {
13888       {
13889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13890       };
13891     }
13892   }
13893
13894 }
13895
13896
13897 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13898   float jresult ;
13899   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13900   float result;
13901
13902   arg1 = (Dali::Matrix3 *)jarg1;
13903   {
13904     try {
13905       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13906     } catch (std::out_of_range& e) {
13907       {
13908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13909       };
13910     } catch (std::exception& e) {
13911       {
13912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13913       };
13914     } catch (Dali::DaliException e) {
13915       {
13916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13917       };
13918     } catch (...) {
13919       {
13920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13921       };
13922     }
13923   }
13924
13925   jresult = result;
13926   return jresult;
13927 }
13928
13929
13930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13931   unsigned int jresult ;
13932   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13933   bool result;
13934
13935   arg1 = (Dali::Matrix3 *)jarg1;
13936   {
13937     try {
13938       result = (bool)(arg1)->ScaledInverseTranspose();
13939     } catch (std::out_of_range& e) {
13940       {
13941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13942       };
13943     } catch (std::exception& e) {
13944       {
13945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13946       };
13947     } catch (Dali::DaliException e) {
13948       {
13949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13950       };
13951     } catch (...) {
13952       {
13953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13954       };
13955     }
13956   }
13957
13958   jresult = result;
13959   return jresult;
13960 }
13961
13962
13963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13964   Dali::Matrix3 *arg1 = 0 ;
13965   Dali::Matrix3 *arg2 = 0 ;
13966   Dali::Matrix3 *arg3 = 0 ;
13967
13968   arg1 = (Dali::Matrix3 *)jarg1;
13969   if (!arg1) {
13970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13971     return ;
13972   }
13973   arg2 = (Dali::Matrix3 *)jarg2;
13974   if (!arg2) {
13975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13976     return ;
13977   }
13978   arg3 = (Dali::Matrix3 *)jarg3;
13979   if (!arg3) {
13980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13981     return ;
13982   }
13983   {
13984     try {
13985       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13986     } catch (std::out_of_range& e) {
13987       {
13988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13989       };
13990     } catch (std::exception& e) {
13991       {
13992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13993       };
13994     } catch (Dali::DaliException e) {
13995       {
13996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13997       };
13998     } catch (...) {
13999       {
14000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14001       };
14002     }
14003   }
14004
14005 }
14006
14007
14008 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14009   float jresult ;
14010   float arg1 ;
14011   float arg2 ;
14012   float result;
14013
14014   arg1 = (float)jarg1;
14015   arg2 = (float)jarg2;
14016   {
14017     try {
14018       result = (float)Dali::Random::Range(arg1,arg2);
14019     } catch (std::out_of_range& e) {
14020       {
14021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14022       };
14023     } catch (std::exception& e) {
14024       {
14025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14026       };
14027     } catch (Dali::DaliException e) {
14028       {
14029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14030       };
14031     } catch (...) {
14032       {
14033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14034       };
14035     }
14036   }
14037
14038   jresult = result;
14039   return jresult;
14040 }
14041
14042
14043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14044   void * jresult ;
14045   Dali::Vector4 result;
14046
14047   {
14048     try {
14049       result = Dali::Random::Axis();
14050     } catch (std::out_of_range& e) {
14051       {
14052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14053       };
14054     } catch (std::exception& e) {
14055       {
14056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14057       };
14058     } catch (Dali::DaliException e) {
14059       {
14060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14061       };
14062     } catch (...) {
14063       {
14064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14065       };
14066     }
14067   }
14068
14069   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14070   return jresult;
14071 }
14072
14073
14074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14075   void * jresult ;
14076   Dali::AngleAxis *result = 0 ;
14077
14078   {
14079     try {
14080       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14081     } catch (std::out_of_range& e) {
14082       {
14083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14084       };
14085     } catch (std::exception& e) {
14086       {
14087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14088       };
14089     } catch (Dali::DaliException e) {
14090       {
14091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14092       };
14093     } catch (...) {
14094       {
14095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14096       };
14097     }
14098   }
14099
14100   jresult = (void *)result;
14101   return jresult;
14102 }
14103
14104
14105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14106   void * jresult ;
14107   Dali::Radian arg1 ;
14108   Dali::Vector3 *arg2 = 0 ;
14109   Dali::Radian *argp1 ;
14110   Dali::AngleAxis *result = 0 ;
14111
14112   argp1 = (Dali::Radian *)jarg1;
14113   if (!argp1) {
14114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14115     return 0;
14116   }
14117   arg1 = *argp1;
14118   arg2 = (Dali::Vector3 *)jarg2;
14119   if (!arg2) {
14120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14121     return 0;
14122   }
14123   {
14124     try {
14125       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14126     } catch (std::out_of_range& e) {
14127       {
14128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14129       };
14130     } catch (std::exception& e) {
14131       {
14132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14133       };
14134     } catch (Dali::DaliException e) {
14135       {
14136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14137       };
14138     } catch (...) {
14139       {
14140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14141       };
14142     }
14143   }
14144
14145   jresult = (void *)result;
14146   return jresult;
14147 }
14148
14149
14150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14151   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14152   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14153
14154   arg1 = (Dali::AngleAxis *)jarg1;
14155   arg2 = (Dali::Radian *)jarg2;
14156   if (arg1) (arg1)->angle = *arg2;
14157 }
14158
14159
14160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14161   void * jresult ;
14162   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14163   Dali::Radian *result = 0 ;
14164
14165   arg1 = (Dali::AngleAxis *)jarg1;
14166   result = (Dali::Radian *)& ((arg1)->angle);
14167   jresult = (void *)result;
14168   return jresult;
14169 }
14170
14171
14172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14173   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14174   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14175
14176   arg1 = (Dali::AngleAxis *)jarg1;
14177   arg2 = (Dali::Vector3 *)jarg2;
14178   if (arg1) (arg1)->axis = *arg2;
14179 }
14180
14181
14182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14183   void * jresult ;
14184   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14185   Dali::Vector3 *result = 0 ;
14186
14187   arg1 = (Dali::AngleAxis *)jarg1;
14188   result = (Dali::Vector3 *)& ((arg1)->axis);
14189   jresult = (void *)result;
14190   return jresult;
14191 }
14192
14193
14194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14195   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14196
14197   arg1 = (Dali::AngleAxis *)jarg1;
14198   {
14199     try {
14200       delete arg1;
14201     } catch (std::out_of_range& e) {
14202       {
14203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14204       };
14205     } catch (std::exception& e) {
14206       {
14207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14208       };
14209     } catch (Dali::DaliException e) {
14210       {
14211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14212       };
14213     } catch (...) {
14214       {
14215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14216       };
14217     }
14218   }
14219
14220 }
14221
14222
14223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14224   unsigned int jresult ;
14225   Dali::AngleAxis *arg1 = 0 ;
14226   Dali::AngleAxis *arg2 = 0 ;
14227   bool result;
14228
14229   arg1 = (Dali::AngleAxis *)jarg1;
14230   if (!arg1) {
14231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14232     return 0;
14233   }
14234   arg2 = (Dali::AngleAxis *)jarg2;
14235   if (!arg2) {
14236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14237     return 0;
14238   }
14239   {
14240     try {
14241       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14242     } catch (std::out_of_range& e) {
14243       {
14244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14245       };
14246     } catch (std::exception& e) {
14247       {
14248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14249       };
14250     } catch (Dali::DaliException e) {
14251       {
14252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14253       };
14254     } catch (...) {
14255       {
14256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14257       };
14258     }
14259   }
14260
14261   jresult = result;
14262   return jresult;
14263 }
14264
14265
14266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14267   unsigned int jresult ;
14268   unsigned int arg1 ;
14269   unsigned int result;
14270
14271   arg1 = (unsigned int)jarg1;
14272   {
14273     try {
14274       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14275     } catch (std::out_of_range& e) {
14276       {
14277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14278       };
14279     } catch (std::exception& e) {
14280       {
14281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14282       };
14283     } catch (Dali::DaliException e) {
14284       {
14285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14286       };
14287     } catch (...) {
14288       {
14289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14290       };
14291     }
14292   }
14293
14294   jresult = result;
14295   return jresult;
14296 }
14297
14298
14299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14300   unsigned int jresult ;
14301   unsigned int arg1 ;
14302   bool result;
14303
14304   arg1 = (unsigned int)jarg1;
14305   {
14306     try {
14307       result = (bool)Dali::IsPowerOfTwo(arg1);
14308     } catch (std::out_of_range& e) {
14309       {
14310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14311       };
14312     } catch (std::exception& e) {
14313       {
14314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14315       };
14316     } catch (Dali::DaliException e) {
14317       {
14318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14319       };
14320     } catch (...) {
14321       {
14322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14323       };
14324     }
14325   }
14326
14327   jresult = result;
14328   return jresult;
14329 }
14330
14331
14332 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14333   float jresult ;
14334   float arg1 ;
14335   float arg2 ;
14336   float result;
14337
14338   arg1 = (float)jarg1;
14339   arg2 = (float)jarg2;
14340   {
14341     try {
14342       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14343     } catch (std::out_of_range& e) {
14344       {
14345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14346       };
14347     } catch (std::exception& e) {
14348       {
14349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14350       };
14351     } catch (Dali::DaliException e) {
14352       {
14353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14354       };
14355     } catch (...) {
14356       {
14357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14358       };
14359     }
14360   }
14361
14362   jresult = result;
14363   return jresult;
14364 }
14365
14366
14367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14368   unsigned int jresult ;
14369   float arg1 ;
14370   bool result;
14371
14372   arg1 = (float)jarg1;
14373   {
14374     try {
14375       result = (bool)Dali::EqualsZero(arg1);
14376     } catch (std::out_of_range& e) {
14377       {
14378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14379       };
14380     } catch (std::exception& e) {
14381       {
14382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14383       };
14384     } catch (Dali::DaliException e) {
14385       {
14386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14387       };
14388     } catch (...) {
14389       {
14390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14391       };
14392     }
14393   }
14394
14395   jresult = result;
14396   return jresult;
14397 }
14398
14399
14400 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14401   unsigned int jresult ;
14402   float arg1 ;
14403   float arg2 ;
14404   bool result;
14405
14406   arg1 = (float)jarg1;
14407   arg2 = (float)jarg2;
14408   {
14409     try {
14410       result = (bool)Dali::Equals(arg1,arg2);
14411     } catch (std::out_of_range& e) {
14412       {
14413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14414       };
14415     } catch (std::exception& e) {
14416       {
14417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14418       };
14419     } catch (Dali::DaliException e) {
14420       {
14421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14422       };
14423     } catch (...) {
14424       {
14425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14426       };
14427     }
14428   }
14429
14430   jresult = result;
14431   return jresult;
14432 }
14433
14434
14435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14436   unsigned int jresult ;
14437   float arg1 ;
14438   float arg2 ;
14439   float arg3 ;
14440   bool result;
14441
14442   arg1 = (float)jarg1;
14443   arg2 = (float)jarg2;
14444   arg3 = (float)jarg3;
14445   {
14446     try {
14447       result = (bool)Dali::Equals(arg1,arg2,arg3);
14448     } catch (std::out_of_range& e) {
14449       {
14450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14451       };
14452     } catch (std::exception& e) {
14453       {
14454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14455       };
14456     } catch (Dali::DaliException e) {
14457       {
14458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14459       };
14460     } catch (...) {
14461       {
14462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14463       };
14464     }
14465   }
14466
14467   jresult = result;
14468   return jresult;
14469 }
14470
14471
14472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14473   float jresult ;
14474   float arg1 ;
14475   int arg2 ;
14476   float result;
14477
14478   arg1 = (float)jarg1;
14479   arg2 = (int)jarg2;
14480   {
14481     try {
14482       result = (float)Dali::Round(arg1,arg2);
14483     } catch (std::out_of_range& e) {
14484       {
14485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14486       };
14487     } catch (std::exception& e) {
14488       {
14489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14490       };
14491     } catch (Dali::DaliException e) {
14492       {
14493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14494       };
14495     } catch (...) {
14496       {
14497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14498       };
14499     }
14500   }
14501
14502   jresult = result;
14503   return jresult;
14504 }
14505
14506
14507 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14508   float jresult ;
14509   float arg1 ;
14510   float arg2 ;
14511   float arg3 ;
14512   float result;
14513
14514   arg1 = (float)jarg1;
14515   arg2 = (float)jarg2;
14516   arg3 = (float)jarg3;
14517   {
14518     try {
14519       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14520     } catch (std::out_of_range& e) {
14521       {
14522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14523       };
14524     } catch (std::exception& e) {
14525       {
14526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14527       };
14528     } catch (Dali::DaliException e) {
14529       {
14530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14531       };
14532     } catch (...) {
14533       {
14534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14535       };
14536     }
14537   }
14538
14539   jresult = result;
14540   return jresult;
14541 }
14542
14543
14544 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14545   float jresult ;
14546   float arg1 ;
14547   float arg2 ;
14548   float arg3 ;
14549   float arg4 ;
14550   float result;
14551
14552   arg1 = (float)jarg1;
14553   arg2 = (float)jarg2;
14554   arg3 = (float)jarg3;
14555   arg4 = (float)jarg4;
14556   {
14557     try {
14558       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14559     } catch (std::out_of_range& e) {
14560       {
14561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14562       };
14563     } catch (std::exception& e) {
14564       {
14565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14566       };
14567     } catch (Dali::DaliException e) {
14568       {
14569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14570       };
14571     } catch (...) {
14572       {
14573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14574       };
14575     }
14576   }
14577
14578   jresult = result;
14579   return jresult;
14580 }
14581
14582
14583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14584   int jresult ;
14585   int result;
14586
14587   result = (int)(int)Dali::Property::INVALID_INDEX;
14588   jresult = result;
14589   return jresult;
14590 }
14591
14592
14593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14594   int jresult ;
14595   int result;
14596
14597   result = (int)(int)Dali::Property::INVALID_KEY;
14598   jresult = result;
14599   return jresult;
14600 }
14601
14602
14603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14604   int jresult ;
14605   int result;
14606
14607   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14608   jresult = result;
14609   return jresult;
14610 }
14611
14612
14613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14614   void * jresult ;
14615   Dali::Handle *arg1 = 0 ;
14616   Dali::Property::Index arg2 ;
14617   Dali::Property *result = 0 ;
14618
14619   arg1 = (Dali::Handle *)jarg1;
14620   if (!arg1) {
14621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14622     return 0;
14623   }
14624   arg2 = (Dali::Property::Index)jarg2;
14625   {
14626     try {
14627       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14628     } catch (std::out_of_range& e) {
14629       {
14630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14631       };
14632     } catch (std::exception& e) {
14633       {
14634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14635       };
14636     } catch (Dali::DaliException e) {
14637       {
14638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14639       };
14640     } catch (...) {
14641       {
14642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14643       };
14644     }
14645   }
14646
14647   jresult = (void *)result;
14648   return jresult;
14649 }
14650
14651
14652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14653   void * jresult ;
14654   Dali::Handle *arg1 = 0 ;
14655   Dali::Property::Index arg2 ;
14656   int arg3 ;
14657   Dali::Property *result = 0 ;
14658
14659   arg1 = (Dali::Handle *)jarg1;
14660   if (!arg1) {
14661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14662     return 0;
14663   }
14664   arg2 = (Dali::Property::Index)jarg2;
14665   arg3 = (int)jarg3;
14666   {
14667     try {
14668       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14669     } catch (std::out_of_range& e) {
14670       {
14671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14672       };
14673     } catch (std::exception& e) {
14674       {
14675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14676       };
14677     } catch (Dali::DaliException e) {
14678       {
14679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14680       };
14681     } catch (...) {
14682       {
14683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14684       };
14685     }
14686   }
14687
14688   jresult = (void *)result;
14689   return jresult;
14690 }
14691
14692
14693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14694   void * jresult ;
14695   Dali::Handle *arg1 = 0 ;
14696   std::string *arg2 = 0 ;
14697   Dali::Property *result = 0 ;
14698
14699   arg1 = (Dali::Handle *)jarg1;
14700   if (!arg1) {
14701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14702     return 0;
14703   }
14704   if (!jarg2) {
14705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14706     return 0;
14707   }
14708   std::string arg2_str(jarg2);
14709   arg2 = &arg2_str;
14710   {
14711     try {
14712       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14713     } catch (std::out_of_range& e) {
14714       {
14715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14716       };
14717     } catch (std::exception& e) {
14718       {
14719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14720       };
14721     } catch (Dali::DaliException e) {
14722       {
14723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14724       };
14725     } catch (...) {
14726       {
14727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14728       };
14729     }
14730   }
14731
14732   jresult = (void *)result;
14733
14734   //argout typemap for const std::string&
14735
14736   return jresult;
14737 }
14738
14739
14740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14741   void * jresult ;
14742   Dali::Handle *arg1 = 0 ;
14743   std::string *arg2 = 0 ;
14744   int arg3 ;
14745   Dali::Property *result = 0 ;
14746
14747   arg1 = (Dali::Handle *)jarg1;
14748   if (!arg1) {
14749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14750     return 0;
14751   }
14752   if (!jarg2) {
14753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14754     return 0;
14755   }
14756   std::string arg2_str(jarg2);
14757   arg2 = &arg2_str;
14758   arg3 = (int)jarg3;
14759   {
14760     try {
14761       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14762     } catch (std::out_of_range& e) {
14763       {
14764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14765       };
14766     } catch (std::exception& e) {
14767       {
14768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14769       };
14770     } catch (Dali::DaliException e) {
14771       {
14772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14773       };
14774     } catch (...) {
14775       {
14776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14777       };
14778     }
14779   }
14780
14781   jresult = (void *)result;
14782
14783   //argout typemap for const std::string&
14784
14785   return jresult;
14786 }
14787
14788
14789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14790   Dali::Property *arg1 = (Dali::Property *) 0 ;
14791
14792   arg1 = (Dali::Property *)jarg1;
14793   {
14794     try {
14795       delete arg1;
14796     } catch (std::out_of_range& e) {
14797       {
14798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14799       };
14800     } catch (std::exception& e) {
14801       {
14802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14803       };
14804     } catch (Dali::DaliException e) {
14805       {
14806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14807       };
14808     } catch (...) {
14809       {
14810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14811       };
14812     }
14813   }
14814
14815 }
14816
14817
14818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14819   Dali::Property *arg1 = (Dali::Property *) 0 ;
14820   Dali::Handle *arg2 = 0 ;
14821
14822   arg1 = (Dali::Property *)jarg1;
14823   arg2 = (Dali::Handle *)jarg2;
14824   if (!arg2) {
14825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14826     return ;
14827   }
14828   if (arg1) (arg1)->object = *arg2;
14829 }
14830
14831
14832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14833   void * jresult ;
14834   Dali::Property *arg1 = (Dali::Property *) 0 ;
14835   Dali::Handle *result = 0 ;
14836
14837   arg1 = (Dali::Property *)jarg1;
14838   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14839   jresult = (void *)result;
14840   return jresult;
14841 }
14842
14843
14844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14845   Dali::Property *arg1 = (Dali::Property *) 0 ;
14846   Dali::Property::Index arg2 ;
14847
14848   arg1 = (Dali::Property *)jarg1;
14849   arg2 = (Dali::Property::Index)jarg2;
14850   if (arg1) (arg1)->propertyIndex = arg2;
14851 }
14852
14853
14854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14855   int jresult ;
14856   Dali::Property *arg1 = (Dali::Property *) 0 ;
14857   Dali::Property::Index result;
14858
14859   arg1 = (Dali::Property *)jarg1;
14860   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14861   jresult = result;
14862   return jresult;
14863 }
14864
14865
14866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14867   Dali::Property *arg1 = (Dali::Property *) 0 ;
14868   int arg2 ;
14869
14870   arg1 = (Dali::Property *)jarg1;
14871   arg2 = (int)jarg2;
14872   if (arg1) (arg1)->componentIndex = arg2;
14873 }
14874
14875
14876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14877   int jresult ;
14878   Dali::Property *arg1 = (Dali::Property *) 0 ;
14879   int result;
14880
14881   arg1 = (Dali::Property *)jarg1;
14882   result = (int) ((arg1)->componentIndex);
14883   jresult = result;
14884   return jresult;
14885 }
14886
14887
14888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14889   void * jresult ;
14890   Dali::Property::Array *result = 0 ;
14891
14892   {
14893     try {
14894       result = (Dali::Property::Array *)new Dali::Property::Array();
14895     } catch (std::out_of_range& e) {
14896       {
14897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14898       };
14899     } catch (std::exception& e) {
14900       {
14901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14902       };
14903     } catch (Dali::DaliException e) {
14904       {
14905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14906       };
14907     } catch (...) {
14908       {
14909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14910       };
14911     }
14912   }
14913
14914   jresult = (void *)result;
14915   return jresult;
14916 }
14917
14918
14919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14920   void * jresult ;
14921   Dali::Property::Array *arg1 = 0 ;
14922   Dali::Property::Array *result = 0 ;
14923
14924   arg1 = (Dali::Property::Array *)jarg1;
14925   if (!arg1) {
14926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14927     return 0;
14928   }
14929   {
14930     try {
14931       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14932     } catch (std::out_of_range& e) {
14933       {
14934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14935       };
14936     } catch (std::exception& e) {
14937       {
14938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14939       };
14940     } catch (Dali::DaliException e) {
14941       {
14942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14943       };
14944     } catch (...) {
14945       {
14946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14947       };
14948     }
14949   }
14950
14951   jresult = (void *)result;
14952   return jresult;
14953 }
14954
14955
14956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14957   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14958
14959   arg1 = (Dali::Property::Array *)jarg1;
14960   {
14961     try {
14962       delete arg1;
14963     } catch (std::out_of_range& e) {
14964       {
14965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14966       };
14967     } catch (std::exception& e) {
14968       {
14969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14970       };
14971     } catch (Dali::DaliException e) {
14972       {
14973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14974       };
14975     } catch (...) {
14976       {
14977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14978       };
14979     }
14980   }
14981
14982 }
14983
14984
14985 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14986   unsigned long jresult ;
14987   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14988   Dali::Property::Array::SizeType result;
14989
14990   arg1 = (Dali::Property::Array *)jarg1;
14991   {
14992     try {
14993       result = ((Dali::Property::Array const *)arg1)->Size();
14994     } catch (std::out_of_range& e) {
14995       {
14996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14997       };
14998     } catch (std::exception& e) {
14999       {
15000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15001       };
15002     } catch (Dali::DaliException e) {
15003       {
15004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15005       };
15006     } catch (...) {
15007       {
15008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15009       };
15010     }
15011   }
15012
15013   jresult = (unsigned long)result;
15014   return jresult;
15015 }
15016
15017
15018 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15019   unsigned long jresult ;
15020   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15021   Dali::Property::Array::SizeType result;
15022
15023   arg1 = (Dali::Property::Array *)jarg1;
15024   {
15025     try {
15026       result = ((Dali::Property::Array const *)arg1)->Count();
15027     } catch (std::out_of_range& e) {
15028       {
15029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15030       };
15031     } catch (std::exception& e) {
15032       {
15033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15034       };
15035     } catch (Dali::DaliException e) {
15036       {
15037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15038       };
15039     } catch (...) {
15040       {
15041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15042       };
15043     }
15044   }
15045
15046   jresult = (unsigned long)result;
15047   return jresult;
15048 }
15049
15050
15051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15052   unsigned int jresult ;
15053   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15054   bool result;
15055
15056   arg1 = (Dali::Property::Array *)jarg1;
15057   {
15058     try {
15059       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15060     } catch (std::out_of_range& e) {
15061       {
15062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15063       };
15064     } catch (std::exception& e) {
15065       {
15066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15067       };
15068     } catch (Dali::DaliException e) {
15069       {
15070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15071       };
15072     } catch (...) {
15073       {
15074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15075       };
15076     }
15077   }
15078
15079   jresult = result;
15080   return jresult;
15081 }
15082
15083
15084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15085   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15086
15087   arg1 = (Dali::Property::Array *)jarg1;
15088   {
15089     try {
15090       (arg1)->Clear();
15091     } catch (std::out_of_range& e) {
15092       {
15093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15094       };
15095     } catch (std::exception& e) {
15096       {
15097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15098       };
15099     } catch (Dali::DaliException e) {
15100       {
15101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15102       };
15103     } catch (...) {
15104       {
15105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15106       };
15107     }
15108   }
15109
15110 }
15111
15112
15113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15114   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15115   Dali::Property::Array::SizeType arg2 ;
15116
15117   arg1 = (Dali::Property::Array *)jarg1;
15118   arg2 = (Dali::Property::Array::SizeType)jarg2;
15119   {
15120     try {
15121       (arg1)->Reserve(arg2);
15122     } catch (std::out_of_range& e) {
15123       {
15124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15125       };
15126     } catch (std::exception& e) {
15127       {
15128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15129       };
15130     } catch (Dali::DaliException e) {
15131       {
15132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15133       };
15134     } catch (...) {
15135       {
15136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15137       };
15138     }
15139   }
15140
15141 }
15142
15143
15144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15145   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15146   Dali::Property::Array::SizeType arg2 ;
15147
15148   arg1 = (Dali::Property::Array *)jarg1;
15149   arg2 = (Dali::Property::Array::SizeType)jarg2;
15150   {
15151     try {
15152       (arg1)->Resize(arg2);
15153     } catch (std::out_of_range& e) {
15154       {
15155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15156       };
15157     } catch (std::exception& e) {
15158       {
15159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15160       };
15161     } catch (Dali::DaliException e) {
15162       {
15163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15164       };
15165     } catch (...) {
15166       {
15167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15168       };
15169     }
15170   }
15171
15172 }
15173
15174
15175 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15176   unsigned long jresult ;
15177   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15178   Dali::Property::Array::SizeType result;
15179
15180   arg1 = (Dali::Property::Array *)jarg1;
15181   {
15182     try {
15183       result = (arg1)->Capacity();
15184     } catch (std::out_of_range& e) {
15185       {
15186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15187       };
15188     } catch (std::exception& e) {
15189       {
15190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15191       };
15192     } catch (Dali::DaliException e) {
15193       {
15194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15195       };
15196     } catch (...) {
15197       {
15198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15199       };
15200     }
15201   }
15202
15203   jresult = (unsigned long)result;
15204   return jresult;
15205 }
15206
15207
15208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15209   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15210   Dali::Property::Value *arg2 = 0 ;
15211
15212   arg1 = (Dali::Property::Array *)jarg1;
15213   arg2 = (Dali::Property::Value *)jarg2;
15214   if (!arg2) {
15215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15216     return ;
15217   }
15218   {
15219     try {
15220       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15221     } catch (std::out_of_range& e) {
15222       {
15223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15224       };
15225     } catch (std::exception& e) {
15226       {
15227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15228       };
15229     } catch (Dali::DaliException e) {
15230       {
15231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15232       };
15233     } catch (...) {
15234       {
15235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15236       };
15237     }
15238   }
15239
15240 }
15241
15242
15243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15244   void * jresult ;
15245   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15246   Dali::Property::Value *arg2 = 0 ;
15247   Dali::Property::Array *result = 0 ;
15248
15249   arg1 = (Dali::Property::Array *)jarg1;
15250   arg2 = (Dali::Property::Value *)jarg2;
15251   if (!arg2) {
15252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15253     return 0;
15254   }
15255   {
15256     try {
15257       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15258     } catch (std::out_of_range& e) {
15259       {
15260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15261       };
15262     } catch (std::exception& e) {
15263       {
15264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15265       };
15266     } catch (Dali::DaliException e) {
15267       {
15268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15269       };
15270     } catch (...) {
15271       {
15272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15273       };
15274     }
15275   }
15276
15277   jresult = (void *)result;
15278   return jresult;
15279 }
15280
15281
15282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15283   void * jresult ;
15284   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15285   Dali::Property::Array::SizeType arg2 ;
15286   Dali::Property::Value *result = 0 ;
15287
15288   arg1 = (Dali::Property::Array *)jarg1;
15289   arg2 = (Dali::Property::Array::SizeType)jarg2;
15290   {
15291     try {
15292       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15293     } catch (std::out_of_range& e) {
15294       {
15295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15296       };
15297     } catch (std::exception& e) {
15298       {
15299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15300       };
15301     } catch (Dali::DaliException e) {
15302       {
15303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15304       };
15305     } catch (...) {
15306       {
15307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15308       };
15309     }
15310   }
15311
15312   jresult = (void *)result;
15313   return jresult;
15314 }
15315
15316
15317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15318   void * jresult ;
15319   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15320   Dali::Property::Array::SizeType arg2 ;
15321   Dali::Property::Value *result = 0 ;
15322
15323   arg1 = (Dali::Property::Array *)jarg1;
15324   arg2 = (Dali::Property::Array::SizeType)jarg2;
15325   {
15326     try {
15327       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15328     } catch (std::out_of_range& e) {
15329       {
15330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15331       };
15332     } catch (std::exception& e) {
15333       {
15334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15335       };
15336     } catch (Dali::DaliException e) {
15337       {
15338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15339       };
15340     } catch (...) {
15341       {
15342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15343       };
15344     }
15345   }
15346
15347   jresult = (void *)result;
15348   return jresult;
15349 }
15350
15351
15352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15353   void * jresult ;
15354   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15355   Dali::Property::Array *arg2 = 0 ;
15356   Dali::Property::Array *result = 0 ;
15357
15358   arg1 = (Dali::Property::Array *)jarg1;
15359   arg2 = (Dali::Property::Array *)jarg2;
15360   if (!arg2) {
15361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15362     return 0;
15363   }
15364   {
15365     try {
15366       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15367     } catch (std::out_of_range& e) {
15368       {
15369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15370       };
15371     } catch (std::exception& e) {
15372       {
15373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15374       };
15375     } catch (Dali::DaliException e) {
15376       {
15377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15378       };
15379     } catch (...) {
15380       {
15381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15382       };
15383     }
15384   }
15385
15386   jresult = (void *)result;
15387   return jresult;
15388 }
15389
15390
15391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15392   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15393   enum Dali::Property::Key::Type arg2 ;
15394
15395   arg1 = (Dali::Property::Key *)jarg1;
15396   arg2 = (enum Dali::Property::Key::Type)jarg2;
15397   if (arg1) (arg1)->type = arg2;
15398 }
15399
15400
15401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15402   int jresult ;
15403   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15404   enum Dali::Property::Key::Type result;
15405
15406   arg1 = (Dali::Property::Key *)jarg1;
15407   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15408   jresult = (int)result;
15409   return jresult;
15410 }
15411
15412
15413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15414   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15415   Dali::Property::Index arg2 ;
15416
15417   arg1 = (Dali::Property::Key *)jarg1;
15418   arg2 = (Dali::Property::Index)jarg2;
15419   if (arg1) (arg1)->indexKey = arg2;
15420 }
15421
15422
15423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15424   int jresult ;
15425   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15426   Dali::Property::Index result;
15427
15428   arg1 = (Dali::Property::Key *)jarg1;
15429   result = (Dali::Property::Index) ((arg1)->indexKey);
15430   jresult = result;
15431   return jresult;
15432 }
15433
15434
15435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15436   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15437   std::string *arg2 = 0 ;
15438
15439   arg1 = (Dali::Property::Key *)jarg1;
15440   if (!jarg2) {
15441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15442     return ;
15443   }
15444   std::string arg2_str(jarg2);
15445   arg2 = &arg2_str;
15446   if (arg1) (arg1)->stringKey = *arg2;
15447
15448   //argout typemap for const std::string&
15449
15450 }
15451
15452
15453 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15454   char * jresult ;
15455   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15456   std::string *result = 0 ;
15457
15458   arg1 = (Dali::Property::Key *)jarg1;
15459   result = (std::string *) & ((arg1)->stringKey);
15460   jresult = SWIG_csharp_string_callback(result->c_str());
15461   return jresult;
15462 }
15463
15464
15465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15466   void * jresult ;
15467   std::string *arg1 = 0 ;
15468   Dali::Property::Key *result = 0 ;
15469
15470   if (!jarg1) {
15471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15472     return 0;
15473   }
15474   std::string arg1_str(jarg1);
15475   arg1 = &arg1_str;
15476   {
15477     try {
15478       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15479     } catch (std::out_of_range& e) {
15480       {
15481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15482       };
15483     } catch (std::exception& e) {
15484       {
15485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15486       };
15487     } catch (Dali::DaliException e) {
15488       {
15489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15490       };
15491     } catch (...) {
15492       {
15493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15494       };
15495     }
15496   }
15497
15498   jresult = (void *)result;
15499
15500   //argout typemap for const std::string&
15501
15502   return jresult;
15503 }
15504
15505
15506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15507   void * jresult ;
15508   Dali::Property::Index arg1 ;
15509   Dali::Property::Key *result = 0 ;
15510
15511   arg1 = (Dali::Property::Index)jarg1;
15512   {
15513     try {
15514       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15515     } catch (std::out_of_range& e) {
15516       {
15517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15518       };
15519     } catch (std::exception& e) {
15520       {
15521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15522       };
15523     } catch (Dali::DaliException e) {
15524       {
15525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15526       };
15527     } catch (...) {
15528       {
15529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15530       };
15531     }
15532   }
15533
15534   jresult = (void *)result;
15535   return jresult;
15536 }
15537
15538
15539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15540   unsigned int jresult ;
15541   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15542   std::string *arg2 = 0 ;
15543   bool result;
15544
15545   arg1 = (Dali::Property::Key *)jarg1;
15546   if (!jarg2) {
15547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15548     return 0;
15549   }
15550   std::string arg2_str(jarg2);
15551   arg2 = &arg2_str;
15552   {
15553     try {
15554       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15555     } catch (std::out_of_range& e) {
15556       {
15557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15558       };
15559     } catch (std::exception& e) {
15560       {
15561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15562       };
15563     } catch (Dali::DaliException e) {
15564       {
15565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15566       };
15567     } catch (...) {
15568       {
15569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15570       };
15571     }
15572   }
15573
15574   jresult = result;
15575
15576   //argout typemap for const std::string&
15577
15578   return jresult;
15579 }
15580
15581
15582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15583   unsigned int jresult ;
15584   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15585   Dali::Property::Index arg2 ;
15586   bool result;
15587
15588   arg1 = (Dali::Property::Key *)jarg1;
15589   arg2 = (Dali::Property::Index)jarg2;
15590   {
15591     try {
15592       result = (bool)(arg1)->operator ==(arg2);
15593     } catch (std::out_of_range& e) {
15594       {
15595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15596       };
15597     } catch (std::exception& e) {
15598       {
15599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15600       };
15601     } catch (Dali::DaliException e) {
15602       {
15603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15604       };
15605     } catch (...) {
15606       {
15607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15608       };
15609     }
15610   }
15611
15612   jresult = result;
15613   return jresult;
15614 }
15615
15616
15617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15618   unsigned int jresult ;
15619   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15620   Dali::Property::Key *arg2 = 0 ;
15621   bool result;
15622
15623   arg1 = (Dali::Property::Key *)jarg1;
15624   arg2 = (Dali::Property::Key *)jarg2;
15625   if (!arg2) {
15626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15627     return 0;
15628   }
15629   {
15630     try {
15631       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15632     } catch (std::out_of_range& e) {
15633       {
15634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15635       };
15636     } catch (std::exception& e) {
15637       {
15638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15639       };
15640     } catch (Dali::DaliException e) {
15641       {
15642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15643       };
15644     } catch (...) {
15645       {
15646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15647       };
15648     }
15649   }
15650
15651   jresult = result;
15652   return jresult;
15653 }
15654
15655
15656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15657   unsigned int jresult ;
15658   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15659   std::string *arg2 = 0 ;
15660   bool result;
15661
15662   arg1 = (Dali::Property::Key *)jarg1;
15663   if (!jarg2) {
15664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15665     return 0;
15666   }
15667   std::string arg2_str(jarg2);
15668   arg2 = &arg2_str;
15669   {
15670     try {
15671       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15672     } catch (std::out_of_range& e) {
15673       {
15674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15675       };
15676     } catch (std::exception& e) {
15677       {
15678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15679       };
15680     } catch (Dali::DaliException e) {
15681       {
15682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15683       };
15684     } catch (...) {
15685       {
15686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15687       };
15688     }
15689   }
15690
15691   jresult = result;
15692
15693   //argout typemap for const std::string&
15694
15695   return jresult;
15696 }
15697
15698
15699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15700   unsigned int jresult ;
15701   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15702   Dali::Property::Index arg2 ;
15703   bool result;
15704
15705   arg1 = (Dali::Property::Key *)jarg1;
15706   arg2 = (Dali::Property::Index)jarg2;
15707   {
15708     try {
15709       result = (bool)(arg1)->operator !=(arg2);
15710     } catch (std::out_of_range& e) {
15711       {
15712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15713       };
15714     } catch (std::exception& e) {
15715       {
15716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15717       };
15718     } catch (Dali::DaliException e) {
15719       {
15720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15721       };
15722     } catch (...) {
15723       {
15724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15725       };
15726     }
15727   }
15728
15729   jresult = result;
15730   return jresult;
15731 }
15732
15733
15734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15735   unsigned int jresult ;
15736   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15737   Dali::Property::Key *arg2 = 0 ;
15738   bool result;
15739
15740   arg1 = (Dali::Property::Key *)jarg1;
15741   arg2 = (Dali::Property::Key *)jarg2;
15742   if (!arg2) {
15743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15744     return 0;
15745   }
15746   {
15747     try {
15748       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15749     } catch (std::out_of_range& e) {
15750       {
15751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15752       };
15753     } catch (std::exception& e) {
15754       {
15755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15756       };
15757     } catch (Dali::DaliException e) {
15758       {
15759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15760       };
15761     } catch (...) {
15762       {
15763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15764       };
15765     }
15766   }
15767
15768   jresult = result;
15769   return jresult;
15770 }
15771
15772
15773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15774   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15775
15776   arg1 = (Dali::Property::Key *)jarg1;
15777   {
15778     try {
15779       delete arg1;
15780     } catch (std::out_of_range& e) {
15781       {
15782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15783       };
15784     } catch (std::exception& e) {
15785       {
15786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15787       };
15788     } catch (Dali::DaliException e) {
15789       {
15790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15791       };
15792     } catch (...) {
15793       {
15794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15795       };
15796     }
15797   }
15798
15799 }
15800
15801
15802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15803   void * jresult ;
15804   Dali::Property::Map *result = 0 ;
15805
15806   {
15807     try {
15808       result = (Dali::Property::Map *)new Dali::Property::Map();
15809     } catch (std::out_of_range& e) {
15810       {
15811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15812       };
15813     } catch (std::exception& e) {
15814       {
15815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15816       };
15817     } catch (Dali::DaliException e) {
15818       {
15819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15820       };
15821     } catch (...) {
15822       {
15823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15824       };
15825     }
15826   }
15827
15828   jresult = (void *)result;
15829   return jresult;
15830 }
15831
15832
15833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15834   void * jresult ;
15835   Dali::Property::Map *arg1 = 0 ;
15836   Dali::Property::Map *result = 0 ;
15837
15838   arg1 = (Dali::Property::Map *)jarg1;
15839   if (!arg1) {
15840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15841     return 0;
15842   }
15843   {
15844     try {
15845       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15846     } catch (std::out_of_range& e) {
15847       {
15848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15849       };
15850     } catch (std::exception& e) {
15851       {
15852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15853       };
15854     } catch (Dali::DaliException e) {
15855       {
15856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15857       };
15858     } catch (...) {
15859       {
15860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15861       };
15862     }
15863   }
15864
15865   jresult = (void *)result;
15866   return jresult;
15867 }
15868
15869
15870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15871   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15872
15873   arg1 = (Dali::Property::Map *)jarg1;
15874   {
15875     try {
15876       delete arg1;
15877     } catch (std::out_of_range& e) {
15878       {
15879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15880       };
15881     } catch (std::exception& e) {
15882       {
15883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15884       };
15885     } catch (Dali::DaliException e) {
15886       {
15887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15888       };
15889     } catch (...) {
15890       {
15891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15892       };
15893     }
15894   }
15895
15896 }
15897
15898
15899 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15900   unsigned long jresult ;
15901   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15902   Dali::Property::Map::SizeType result;
15903
15904   arg1 = (Dali::Property::Map *)jarg1;
15905   {
15906     try {
15907       result = ((Dali::Property::Map const *)arg1)->Count();
15908     } catch (std::out_of_range& e) {
15909       {
15910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15911       };
15912     } catch (std::exception& e) {
15913       {
15914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15915       };
15916     } catch (Dali::DaliException e) {
15917       {
15918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15919       };
15920     } catch (...) {
15921       {
15922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15923       };
15924     }
15925   }
15926
15927   jresult = (unsigned long)result;
15928   return jresult;
15929 }
15930
15931
15932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15933   unsigned int jresult ;
15934   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15935   bool result;
15936
15937   arg1 = (Dali::Property::Map *)jarg1;
15938   {
15939     try {
15940       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15941     } catch (std::out_of_range& e) {
15942       {
15943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15944       };
15945     } catch (std::exception& e) {
15946       {
15947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15948       };
15949     } catch (Dali::DaliException e) {
15950       {
15951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15952       };
15953     } catch (...) {
15954       {
15955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15956       };
15957     }
15958   }
15959
15960   jresult = result;
15961   return jresult;
15962 }
15963
15964
15965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15966   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15967   char *arg2 = (char *) 0 ;
15968   Dali::Property::Value *arg3 = 0 ;
15969
15970   arg1 = (Dali::Property::Map *)jarg1;
15971   arg2 = (char *)jarg2;
15972   arg3 = (Dali::Property::Value *)jarg3;
15973   if (!arg3) {
15974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15975     return ;
15976   }
15977   {
15978     try {
15979       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15980     } catch (std::out_of_range& e) {
15981       {
15982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15983       };
15984     } catch (std::exception& e) {
15985       {
15986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15987       };
15988     } catch (Dali::DaliException e) {
15989       {
15990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15991       };
15992     } catch (...) {
15993       {
15994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15995       };
15996     }
15997   }
15998
15999 }
16000
16001
16002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16003   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16004   Dali::Property::Index arg2 ;
16005   Dali::Property::Value *arg3 = 0 ;
16006
16007   arg1 = (Dali::Property::Map *)jarg1;
16008   arg2 = (Dali::Property::Index)jarg2;
16009   arg3 = (Dali::Property::Value *)jarg3;
16010   if (!arg3) {
16011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16012     return ;
16013   }
16014   {
16015     try {
16016       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16017     } catch (std::out_of_range& e) {
16018       {
16019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16020       };
16021     } catch (std::exception& e) {
16022       {
16023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16024       };
16025     } catch (Dali::DaliException e) {
16026       {
16027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16028       };
16029     } catch (...) {
16030       {
16031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16032       };
16033     }
16034   }
16035
16036 }
16037
16038
16039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16040   void * jresult ;
16041   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16042   char *arg2 = (char *) 0 ;
16043   Dali::Property::Value *arg3 = 0 ;
16044   Dali::Property::Map *result = 0 ;
16045
16046   arg1 = (Dali::Property::Map *)jarg1;
16047   arg2 = (char *)jarg2;
16048   arg3 = (Dali::Property::Value *)jarg3;
16049   if (!arg3) {
16050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16051     return 0;
16052   }
16053   {
16054     try {
16055       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16056     } catch (std::out_of_range& e) {
16057       {
16058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16059       };
16060     } catch (std::exception& e) {
16061       {
16062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16063       };
16064     } catch (Dali::DaliException e) {
16065       {
16066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16067       };
16068     } catch (...) {
16069       {
16070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16071       };
16072     }
16073   }
16074
16075   jresult = (void *)result;
16076   return jresult;
16077 }
16078
16079
16080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16081   void * jresult ;
16082   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16083   Dali::Property::Index arg2 ;
16084   Dali::Property::Value *arg3 = 0 ;
16085   Dali::Property::Map *result = 0 ;
16086
16087   arg1 = (Dali::Property::Map *)jarg1;
16088   arg2 = (Dali::Property::Index)jarg2;
16089   arg3 = (Dali::Property::Value *)jarg3;
16090   if (!arg3) {
16091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16092     return 0;
16093   }
16094   {
16095     try {
16096       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16097     } catch (std::out_of_range& e) {
16098       {
16099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16100       };
16101     } catch (std::exception& e) {
16102       {
16103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16104       };
16105     } catch (Dali::DaliException e) {
16106       {
16107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16108       };
16109     } catch (...) {
16110       {
16111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16112       };
16113     }
16114   }
16115
16116   jresult = (void *)result;
16117   return jresult;
16118 }
16119
16120
16121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16122   void * jresult ;
16123   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16124   Dali::Property::Map::SizeType arg2 ;
16125   Dali::Property::Value *result = 0 ;
16126
16127   arg1 = (Dali::Property::Map *)jarg1;
16128   arg2 = (Dali::Property::Map::SizeType)jarg2;
16129   {
16130     try {
16131       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16132     } catch (std::out_of_range& e) {
16133       {
16134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16135       };
16136     } catch (std::exception& e) {
16137       {
16138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16139       };
16140     } catch (Dali::DaliException e) {
16141       {
16142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16143       };
16144     } catch (...) {
16145       {
16146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16147       };
16148     }
16149   }
16150
16151   jresult = (void *)result;
16152   return jresult;
16153 }
16154
16155
16156 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16157   char * jresult ;
16158   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16159   Dali::Property::Map::SizeType arg2 ;
16160   std::string *result = 0 ;
16161
16162   arg1 = (Dali::Property::Map *)jarg1;
16163   arg2 = (Dali::Property::Map::SizeType)jarg2;
16164   {
16165     try {
16166       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16167     } catch (std::out_of_range& e) {
16168       {
16169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16170       };
16171     } catch (std::exception& e) {
16172       {
16173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16174       };
16175     } catch (Dali::DaliException e) {
16176       {
16177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16178       };
16179     } catch (...) {
16180       {
16181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16182       };
16183     }
16184   }
16185
16186   jresult = SWIG_csharp_string_callback(result->c_str());
16187   return jresult;
16188 }
16189
16190
16191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16192   void * jresult ;
16193   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16194   Dali::Property::Map::SizeType arg2 ;
16195   SwigValueWrapper< Dali::Property::Key > result;
16196
16197   arg1 = (Dali::Property::Map *)jarg1;
16198   arg2 = (Dali::Property::Map::SizeType)jarg2;
16199   {
16200     try {
16201       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16202     } catch (std::out_of_range& e) {
16203       {
16204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16205       };
16206     } catch (std::exception& e) {
16207       {
16208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16209       };
16210     } catch (Dali::DaliException e) {
16211       {
16212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16213       };
16214     } catch (...) {
16215       {
16216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16217       };
16218     }
16219   }
16220
16221   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16222   return jresult;
16223 }
16224
16225
16226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16227   void * jresult ;
16228   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16229   Dali::Property::Map::SizeType arg2 ;
16230   StringValuePair *result = 0 ;
16231
16232   arg1 = (Dali::Property::Map *)jarg1;
16233   arg2 = (Dali::Property::Map::SizeType)jarg2;
16234   {
16235     try {
16236       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16237     } catch (std::out_of_range& e) {
16238       {
16239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16240       };
16241     } catch (std::exception& e) {
16242       {
16243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16244       };
16245     } catch (Dali::DaliException e) {
16246       {
16247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16248       };
16249     } catch (...) {
16250       {
16251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16252       };
16253     }
16254   }
16255
16256   jresult = (void *)result;
16257   return jresult;
16258 }
16259
16260
16261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16262   void * jresult ;
16263   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16264   char *arg2 = (char *) 0 ;
16265   Dali::Property::Value *result = 0 ;
16266
16267   arg1 = (Dali::Property::Map *)jarg1;
16268   arg2 = (char *)jarg2;
16269   {
16270     try {
16271       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16272     } catch (std::out_of_range& e) {
16273       {
16274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16275       };
16276     } catch (std::exception& e) {
16277       {
16278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16279       };
16280     } catch (Dali::DaliException e) {
16281       {
16282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16283       };
16284     } catch (...) {
16285       {
16286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16287       };
16288     }
16289   }
16290
16291   jresult = (void *)result;
16292   return jresult;
16293 }
16294
16295
16296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16297   void * jresult ;
16298   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16299   Dali::Property::Index arg2 ;
16300   Dali::Property::Value *result = 0 ;
16301
16302   arg1 = (Dali::Property::Map *)jarg1;
16303   arg2 = (Dali::Property::Index)jarg2;
16304   {
16305     try {
16306       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16307     } catch (std::out_of_range& e) {
16308       {
16309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16310       };
16311     } catch (std::exception& e) {
16312       {
16313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16314       };
16315     } catch (Dali::DaliException e) {
16316       {
16317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16318       };
16319     } catch (...) {
16320       {
16321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16322       };
16323     }
16324   }
16325
16326   jresult = (void *)result;
16327   return jresult;
16328 }
16329
16330
16331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16332   void * jresult ;
16333   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16334   Dali::Property::Index arg2 ;
16335   std::string *arg3 = 0 ;
16336   Dali::Property::Value *result = 0 ;
16337
16338   arg1 = (Dali::Property::Map *)jarg1;
16339   arg2 = (Dali::Property::Index)jarg2;
16340   if (!jarg3) {
16341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16342     return 0;
16343   }
16344   std::string arg3_str(jarg3);
16345   arg3 = &arg3_str;
16346   {
16347     try {
16348       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16349     } catch (std::out_of_range& e) {
16350       {
16351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16352       };
16353     } catch (std::exception& e) {
16354       {
16355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16356       };
16357     } catch (Dali::DaliException e) {
16358       {
16359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16360       };
16361     } catch (...) {
16362       {
16363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16364       };
16365     }
16366   }
16367
16368   jresult = (void *)result;
16369
16370   //argout typemap for const std::string&
16371
16372   return jresult;
16373 }
16374
16375
16376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16377   void * jresult ;
16378   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16379   std::string *arg2 = 0 ;
16380   Dali::Property::Type arg3 ;
16381   Dali::Property::Value *result = 0 ;
16382
16383   arg1 = (Dali::Property::Map *)jarg1;
16384   if (!jarg2) {
16385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16386     return 0;
16387   }
16388   std::string arg2_str(jarg2);
16389   arg2 = &arg2_str;
16390   arg3 = (Dali::Property::Type)jarg3;
16391   {
16392     try {
16393       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16394     } catch (std::out_of_range& e) {
16395       {
16396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16397       };
16398     } catch (std::exception& e) {
16399       {
16400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16401       };
16402     } catch (Dali::DaliException e) {
16403       {
16404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16405       };
16406     } catch (...) {
16407       {
16408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16409       };
16410     }
16411   }
16412
16413   jresult = (void *)result;
16414
16415   //argout typemap for const std::string&
16416
16417   return jresult;
16418 }
16419
16420
16421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16422   void * jresult ;
16423   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16424   Dali::Property::Index arg2 ;
16425   Dali::Property::Type arg3 ;
16426   Dali::Property::Value *result = 0 ;
16427
16428   arg1 = (Dali::Property::Map *)jarg1;
16429   arg2 = (Dali::Property::Index)jarg2;
16430   arg3 = (Dali::Property::Type)jarg3;
16431   {
16432     try {
16433       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16434     } catch (std::out_of_range& e) {
16435       {
16436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16437       };
16438     } catch (std::exception& e) {
16439       {
16440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16441       };
16442     } catch (Dali::DaliException e) {
16443       {
16444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16445       };
16446     } catch (...) {
16447       {
16448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16449       };
16450     }
16451   }
16452
16453   jresult = (void *)result;
16454   return jresult;
16455 }
16456
16457
16458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16459   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16460
16461   arg1 = (Dali::Property::Map *)jarg1;
16462   {
16463     try {
16464       (arg1)->Clear();
16465     } catch (std::out_of_range& e) {
16466       {
16467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16468       };
16469     } catch (std::exception& e) {
16470       {
16471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16472       };
16473     } catch (Dali::DaliException e) {
16474       {
16475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16476       };
16477     } catch (...) {
16478       {
16479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16480       };
16481     }
16482   }
16483
16484 }
16485
16486
16487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16488   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16489   Dali::Property::Map *arg2 = 0 ;
16490
16491   arg1 = (Dali::Property::Map *)jarg1;
16492   arg2 = (Dali::Property::Map *)jarg2;
16493   if (!arg2) {
16494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16495     return ;
16496   }
16497   {
16498     try {
16499       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16500     } catch (std::out_of_range& e) {
16501       {
16502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16503       };
16504     } catch (std::exception& e) {
16505       {
16506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16507       };
16508     } catch (Dali::DaliException e) {
16509       {
16510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16511       };
16512     } catch (...) {
16513       {
16514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16515       };
16516     }
16517   }
16518
16519 }
16520
16521
16522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16523   void * jresult ;
16524   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16525   std::string *arg2 = 0 ;
16526   Dali::Property::Value *result = 0 ;
16527
16528   arg1 = (Dali::Property::Map *)jarg1;
16529   if (!jarg2) {
16530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16531     return 0;
16532   }
16533   std::string arg2_str(jarg2);
16534   arg2 = &arg2_str;
16535   {
16536     try {
16537       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16538     } catch (std::out_of_range& e) {
16539       {
16540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16541       };
16542     } catch (std::exception& e) {
16543       {
16544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16545       };
16546     } catch (Dali::DaliException e) {
16547       {
16548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16549       };
16550     } catch (...) {
16551       {
16552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16553       };
16554     }
16555   }
16556
16557   jresult = (void *)result;
16558
16559   //argout typemap for const std::string&
16560
16561   return jresult;
16562 }
16563
16564
16565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16566   void * jresult ;
16567   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16568   Dali::Property::Index arg2 ;
16569   Dali::Property::Value *result = 0 ;
16570
16571   arg1 = (Dali::Property::Map *)jarg1;
16572   arg2 = (Dali::Property::Index)jarg2;
16573   {
16574     try {
16575       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16576     } catch (std::out_of_range& e) {
16577       {
16578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16579       };
16580     } catch (std::exception& e) {
16581       {
16582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16583       };
16584     } catch (Dali::DaliException e) {
16585       {
16586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16587       };
16588     } catch (...) {
16589       {
16590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16591       };
16592     }
16593   }
16594
16595   jresult = (void *)result;
16596   return jresult;
16597 }
16598
16599
16600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16601   void * jresult ;
16602   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16603   Dali::Property::Map *arg2 = 0 ;
16604   Dali::Property::Map *result = 0 ;
16605
16606   arg1 = (Dali::Property::Map *)jarg1;
16607   arg2 = (Dali::Property::Map *)jarg2;
16608   if (!arg2) {
16609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16610     return 0;
16611   }
16612   {
16613     try {
16614       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16615     } catch (std::out_of_range& e) {
16616       {
16617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16618       };
16619     } catch (std::exception& e) {
16620       {
16621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16622       };
16623     } catch (Dali::DaliException e) {
16624       {
16625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16626       };
16627     } catch (...) {
16628       {
16629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16630       };
16631     }
16632   }
16633
16634   jresult = (void *)result;
16635   return jresult;
16636 }
16637
16638
16639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16640   void * jresult ;
16641   Dali::Property::Value *result = 0 ;
16642
16643   {
16644     try {
16645       result = (Dali::Property::Value *)new Dali::Property::Value();
16646     } catch (std::out_of_range& e) {
16647       {
16648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16649       };
16650     } catch (std::exception& e) {
16651       {
16652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16653       };
16654     } catch (Dali::DaliException e) {
16655       {
16656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16657       };
16658     } catch (...) {
16659       {
16660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16661       };
16662     }
16663   }
16664
16665   jresult = (void *)result;
16666   return jresult;
16667 }
16668
16669
16670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16671   void * jresult ;
16672   bool arg1 ;
16673   Dali::Property::Value *result = 0 ;
16674
16675   arg1 = jarg1 ? true : false;
16676   {
16677     try {
16678       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16679     } catch (std::out_of_range& e) {
16680       {
16681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16682       };
16683     } catch (std::exception& e) {
16684       {
16685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16686       };
16687     } catch (Dali::DaliException e) {
16688       {
16689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16690       };
16691     } catch (...) {
16692       {
16693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16694       };
16695     }
16696   }
16697
16698   jresult = (void *)result;
16699   return jresult;
16700 }
16701
16702
16703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16704   void * jresult ;
16705   int arg1 ;
16706   Dali::Property::Value *result = 0 ;
16707
16708   arg1 = (int)jarg1;
16709   {
16710     try {
16711       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16712     } catch (std::out_of_range& e) {
16713       {
16714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16715       };
16716     } catch (std::exception& e) {
16717       {
16718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16719       };
16720     } catch (Dali::DaliException e) {
16721       {
16722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16723       };
16724     } catch (...) {
16725       {
16726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16727       };
16728     }
16729   }
16730
16731   jresult = (void *)result;
16732   return jresult;
16733 }
16734
16735
16736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16737   void * jresult ;
16738   float arg1 ;
16739   Dali::Property::Value *result = 0 ;
16740
16741   arg1 = (float)jarg1;
16742   {
16743     try {
16744       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16745     } catch (std::out_of_range& e) {
16746       {
16747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16748       };
16749     } catch (std::exception& e) {
16750       {
16751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16752       };
16753     } catch (Dali::DaliException e) {
16754       {
16755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16756       };
16757     } catch (...) {
16758       {
16759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16760       };
16761     }
16762   }
16763
16764   jresult = (void *)result;
16765   return jresult;
16766 }
16767
16768
16769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16770   void * jresult ;
16771   Dali::Vector2 *arg1 = 0 ;
16772   Dali::Property::Value *result = 0 ;
16773
16774   arg1 = (Dali::Vector2 *)jarg1;
16775   if (!arg1) {
16776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16777     return 0;
16778   }
16779   {
16780     try {
16781       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16782     } catch (std::out_of_range& e) {
16783       {
16784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16785       };
16786     } catch (std::exception& e) {
16787       {
16788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16789       };
16790     } catch (Dali::DaliException e) {
16791       {
16792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16793       };
16794     } catch (...) {
16795       {
16796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16797       };
16798     }
16799   }
16800
16801   jresult = (void *)result;
16802   return jresult;
16803 }
16804
16805
16806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16807   void * jresult ;
16808   Dali::Vector3 *arg1 = 0 ;
16809   Dali::Property::Value *result = 0 ;
16810
16811   arg1 = (Dali::Vector3 *)jarg1;
16812   if (!arg1) {
16813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16814     return 0;
16815   }
16816   {
16817     try {
16818       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16819     } catch (std::out_of_range& e) {
16820       {
16821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16822       };
16823     } catch (std::exception& e) {
16824       {
16825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16826       };
16827     } catch (Dali::DaliException e) {
16828       {
16829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16830       };
16831     } catch (...) {
16832       {
16833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16834       };
16835     }
16836   }
16837
16838   jresult = (void *)result;
16839   return jresult;
16840 }
16841
16842
16843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16844   void * jresult ;
16845   Dali::Vector4 *arg1 = 0 ;
16846   Dali::Property::Value *result = 0 ;
16847
16848   arg1 = (Dali::Vector4 *)jarg1;
16849   if (!arg1) {
16850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16851     return 0;
16852   }
16853   {
16854     try {
16855       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16856     } catch (std::out_of_range& e) {
16857       {
16858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16859       };
16860     } catch (std::exception& e) {
16861       {
16862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16863       };
16864     } catch (Dali::DaliException e) {
16865       {
16866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16867       };
16868     } catch (...) {
16869       {
16870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16871       };
16872     }
16873   }
16874
16875   jresult = (void *)result;
16876   return jresult;
16877 }
16878
16879
16880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16881   void * jresult ;
16882   Dali::Matrix3 *arg1 = 0 ;
16883   Dali::Property::Value *result = 0 ;
16884
16885   arg1 = (Dali::Matrix3 *)jarg1;
16886   if (!arg1) {
16887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16888     return 0;
16889   }
16890   {
16891     try {
16892       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16893     } catch (std::out_of_range& e) {
16894       {
16895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16896       };
16897     } catch (std::exception& e) {
16898       {
16899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16900       };
16901     } catch (Dali::DaliException e) {
16902       {
16903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16904       };
16905     } catch (...) {
16906       {
16907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16908       };
16909     }
16910   }
16911
16912   jresult = (void *)result;
16913   return jresult;
16914 }
16915
16916
16917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16918   void * jresult ;
16919   Dali::Matrix *arg1 = 0 ;
16920   Dali::Property::Value *result = 0 ;
16921
16922   arg1 = (Dali::Matrix *)jarg1;
16923   if (!arg1) {
16924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16925     return 0;
16926   }
16927   {
16928     try {
16929       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16930     } catch (std::out_of_range& e) {
16931       {
16932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16933       };
16934     } catch (std::exception& e) {
16935       {
16936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16937       };
16938     } catch (Dali::DaliException e) {
16939       {
16940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16941       };
16942     } catch (...) {
16943       {
16944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16945       };
16946     }
16947   }
16948
16949   jresult = (void *)result;
16950   return jresult;
16951 }
16952
16953
16954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16955   void * jresult ;
16956   Dali::Rect< int > *arg1 = 0 ;
16957   Dali::Property::Value *result = 0 ;
16958
16959   arg1 = (Dali::Rect< int > *)jarg1;
16960   if (!arg1) {
16961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16962     return 0;
16963   }
16964   {
16965     try {
16966       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16967     } catch (std::out_of_range& e) {
16968       {
16969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16970       };
16971     } catch (std::exception& e) {
16972       {
16973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16974       };
16975     } catch (Dali::DaliException e) {
16976       {
16977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16978       };
16979     } catch (...) {
16980       {
16981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16982       };
16983     }
16984   }
16985
16986   jresult = (void *)result;
16987   return jresult;
16988 }
16989
16990
16991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
16992   void * jresult ;
16993   Dali::AngleAxis *arg1 = 0 ;
16994   Dali::Property::Value *result = 0 ;
16995
16996   arg1 = (Dali::AngleAxis *)jarg1;
16997   if (!arg1) {
16998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
16999     return 0;
17000   }
17001   {
17002     try {
17003       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17004     } catch (std::out_of_range& e) {
17005       {
17006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17007       };
17008     } catch (std::exception& e) {
17009       {
17010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17011       };
17012     } catch (Dali::DaliException e) {
17013       {
17014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17015       };
17016     } catch (...) {
17017       {
17018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17019       };
17020     }
17021   }
17022
17023   jresult = (void *)result;
17024   return jresult;
17025 }
17026
17027
17028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17029   void * jresult ;
17030   Dali::Quaternion *arg1 = 0 ;
17031   Dali::Property::Value *result = 0 ;
17032
17033   arg1 = (Dali::Quaternion *)jarg1;
17034   if (!arg1) {
17035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17036     return 0;
17037   }
17038   {
17039     try {
17040       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17041     } catch (std::out_of_range& e) {
17042       {
17043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17044       };
17045     } catch (std::exception& e) {
17046       {
17047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17048       };
17049     } catch (Dali::DaliException e) {
17050       {
17051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17052       };
17053     } catch (...) {
17054       {
17055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17056       };
17057     }
17058   }
17059
17060   jresult = (void *)result;
17061   return jresult;
17062 }
17063
17064
17065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17066   void * jresult ;
17067   std::string *arg1 = 0 ;
17068   Dali::Property::Value *result = 0 ;
17069
17070   if (!jarg1) {
17071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17072     return 0;
17073   }
17074   std::string arg1_str(jarg1);
17075   arg1 = &arg1_str;
17076   {
17077     try {
17078       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17079     } catch (std::out_of_range& e) {
17080       {
17081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17082       };
17083     } catch (std::exception& e) {
17084       {
17085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17086       };
17087     } catch (Dali::DaliException e) {
17088       {
17089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17090       };
17091     } catch (...) {
17092       {
17093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17094       };
17095     }
17096   }
17097
17098   jresult = (void *)result;
17099
17100   //argout typemap for const std::string&
17101
17102   return jresult;
17103 }
17104
17105
17106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17107   void * jresult ;
17108   Dali::Property::Array *arg1 = 0 ;
17109   Dali::Property::Value *result = 0 ;
17110
17111   arg1 = (Dali::Property::Array *)jarg1;
17112   if (!arg1) {
17113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17114     return 0;
17115   }
17116   {
17117     try {
17118       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17119     } catch (std::out_of_range& e) {
17120       {
17121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17122       };
17123     } catch (std::exception& e) {
17124       {
17125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17126       };
17127     } catch (Dali::DaliException e) {
17128       {
17129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17130       };
17131     } catch (...) {
17132       {
17133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17134       };
17135     }
17136   }
17137
17138   jresult = (void *)result;
17139   return jresult;
17140 }
17141
17142
17143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17144   void * jresult ;
17145   Dali::Property::Map *arg1 = 0 ;
17146   Dali::Property::Value *result = 0 ;
17147
17148   arg1 = (Dali::Property::Map *)jarg1;
17149   if (!arg1) {
17150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17151     return 0;
17152   }
17153   {
17154     try {
17155       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17156     } catch (std::out_of_range& e) {
17157       {
17158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17159       };
17160     } catch (std::exception& e) {
17161       {
17162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17163       };
17164     } catch (Dali::DaliException e) {
17165       {
17166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17167       };
17168     } catch (...) {
17169       {
17170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17171       };
17172     }
17173   }
17174
17175   jresult = (void *)result;
17176   return jresult;
17177 }
17178
17179
17180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17181   void * jresult ;
17182   Extents *arg1 = 0 ;
17183   Dali::Property::Value *result = 0 ;
17184
17185   arg1 = (Extents *)jarg1;
17186   if (!arg1) {
17187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17188     return 0;
17189   }
17190   {
17191     try {
17192       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17193     } catch (std::out_of_range& e) {
17194       {
17195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17196       };
17197     } catch (std::exception& e) {
17198       {
17199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17200       };
17201     } catch (...) {
17202       {
17203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17204       };
17205     }
17206   }
17207   jresult = (void *)result;
17208   return jresult;
17209 }
17210
17211
17212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17213   void * jresult ;
17214   Dali::Property::Type arg1 ;
17215   Dali::Property::Value *result = 0 ;
17216
17217   arg1 = (Dali::Property::Type)jarg1;
17218   {
17219     try {
17220       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17221     } catch (std::out_of_range& e) {
17222       {
17223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17224       };
17225     } catch (std::exception& e) {
17226       {
17227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17228       };
17229     } catch (Dali::DaliException e) {
17230       {
17231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17232       };
17233     } catch (...) {
17234       {
17235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17236       };
17237     }
17238   }
17239
17240   jresult = (void *)result;
17241   return jresult;
17242 }
17243
17244
17245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17246   void * jresult ;
17247   Dali::Property::Value *arg1 = 0 ;
17248   Dali::Property::Value *result = 0 ;
17249
17250   arg1 = (Dali::Property::Value *)jarg1;
17251   if (!arg1) {
17252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17253     return 0;
17254   }
17255   {
17256     try {
17257       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17258     } catch (std::out_of_range& e) {
17259       {
17260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17261       };
17262     } catch (std::exception& e) {
17263       {
17264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17265       };
17266     } catch (Dali::DaliException e) {
17267       {
17268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17269       };
17270     } catch (...) {
17271       {
17272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17273       };
17274     }
17275   }
17276
17277   jresult = (void *)result;
17278   return jresult;
17279 }
17280
17281
17282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17283   void * jresult ;
17284   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17285   Dali::Property::Value *arg2 = 0 ;
17286   Dali::Property::Value *result = 0 ;
17287
17288   arg1 = (Dali::Property::Value *)jarg1;
17289   arg2 = (Dali::Property::Value *)jarg2;
17290   if (!arg2) {
17291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17292     return 0;
17293   }
17294   {
17295     try {
17296       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17297     } catch (std::out_of_range& e) {
17298       {
17299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17300       };
17301     } catch (std::exception& e) {
17302       {
17303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17304       };
17305     } catch (Dali::DaliException e) {
17306       {
17307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17308       };
17309     } catch (...) {
17310       {
17311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17312       };
17313     }
17314   }
17315
17316   jresult = (void *)result;
17317   return jresult;
17318 }
17319
17320
17321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17322   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17323
17324   arg1 = (Dali::Property::Value *)jarg1;
17325   {
17326     try {
17327       delete arg1;
17328     } catch (std::out_of_range& e) {
17329       {
17330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17331       };
17332     } catch (std::exception& e) {
17333       {
17334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17335       };
17336     } catch (Dali::DaliException e) {
17337       {
17338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17339       };
17340     } catch (...) {
17341       {
17342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17343       };
17344     }
17345   }
17346
17347 }
17348
17349
17350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17351   int jresult ;
17352   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17353   Dali::Property::Type result;
17354
17355   arg1 = (Dali::Property::Value *)jarg1;
17356   {
17357     try {
17358       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17359     } catch (std::out_of_range& e) {
17360       {
17361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17362       };
17363     } catch (std::exception& e) {
17364       {
17365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17366       };
17367     } catch (Dali::DaliException e) {
17368       {
17369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17370       };
17371     } catch (...) {
17372       {
17373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17374       };
17375     }
17376   }
17377
17378   jresult = (int)result;
17379   return jresult;
17380 }
17381
17382
17383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17384   unsigned int jresult ;
17385   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17386   bool *arg2 = 0 ;
17387   bool result;
17388
17389   arg1 = (Dali::Property::Value *)jarg1;
17390   arg2 = (bool *)jarg2;
17391   {
17392     try {
17393       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17394     } catch (std::out_of_range& e) {
17395       {
17396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17397       };
17398     } catch (std::exception& e) {
17399       {
17400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17401       };
17402     } catch (Dali::DaliException e) {
17403       {
17404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17405       };
17406     } catch (...) {
17407       {
17408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17409       };
17410     }
17411   }
17412
17413   jresult = result;
17414   return jresult;
17415 }
17416
17417
17418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17419   unsigned int jresult ;
17420   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17421   float *arg2 = 0 ;
17422   bool result;
17423
17424   arg1 = (Dali::Property::Value *)jarg1;
17425   arg2 = (float *)jarg2;
17426   {
17427     try {
17428       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17429     } catch (std::out_of_range& e) {
17430       {
17431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17432       };
17433     } catch (std::exception& e) {
17434       {
17435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17436       };
17437     } catch (Dali::DaliException e) {
17438       {
17439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17440       };
17441     } catch (...) {
17442       {
17443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17444       };
17445     }
17446   }
17447
17448   jresult = result;
17449   return jresult;
17450 }
17451
17452
17453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17454   unsigned int jresult ;
17455   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17456   int *arg2 = 0 ;
17457   bool result;
17458
17459   arg1 = (Dali::Property::Value *)jarg1;
17460   arg2 = (int *)jarg2;
17461   {
17462     try {
17463       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17464     } catch (std::out_of_range& e) {
17465       {
17466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17467       };
17468     } catch (std::exception& e) {
17469       {
17470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17471       };
17472     } catch (Dali::DaliException e) {
17473       {
17474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17475       };
17476     } catch (...) {
17477       {
17478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17479       };
17480     }
17481   }
17482
17483   jresult = result;
17484   return jresult;
17485 }
17486
17487
17488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17489   unsigned int jresult ;
17490   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17491   Dali::Rect< int > *arg2 = 0 ;
17492   bool result;
17493
17494   arg1 = (Dali::Property::Value *)jarg1;
17495   arg2 = (Dali::Rect< int > *)jarg2;
17496   if (!arg2) {
17497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17498     return 0;
17499   }
17500   {
17501     try {
17502       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17503     } catch (std::out_of_range& e) {
17504       {
17505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17506       };
17507     } catch (std::exception& e) {
17508       {
17509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17510       };
17511     } catch (Dali::DaliException e) {
17512       {
17513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17514       };
17515     } catch (...) {
17516       {
17517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17518       };
17519     }
17520   }
17521
17522   jresult = result;
17523   return jresult;
17524 }
17525
17526
17527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17528   unsigned int jresult ;
17529   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17530   Dali::Vector2 *arg2 = 0 ;
17531   bool result;
17532
17533   arg1 = (Dali::Property::Value *)jarg1;
17534   arg2 = (Dali::Vector2 *)jarg2;
17535   if (!arg2) {
17536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17537     return 0;
17538   }
17539   {
17540     try {
17541       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17542     } catch (std::out_of_range& e) {
17543       {
17544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17545       };
17546     } catch (std::exception& e) {
17547       {
17548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17549       };
17550     } catch (Dali::DaliException e) {
17551       {
17552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17553       };
17554     } catch (...) {
17555       {
17556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17557       };
17558     }
17559   }
17560
17561   jresult = result;
17562   return jresult;
17563 }
17564
17565
17566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17567   unsigned int jresult ;
17568   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17569   Dali::Vector3 *arg2 = 0 ;
17570   bool result;
17571
17572   arg1 = (Dali::Property::Value *)jarg1;
17573   arg2 = (Dali::Vector3 *)jarg2;
17574   if (!arg2) {
17575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17576     return 0;
17577   }
17578   {
17579     try {
17580       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17581     } catch (std::out_of_range& e) {
17582       {
17583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17584       };
17585     } catch (std::exception& e) {
17586       {
17587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17588       };
17589     } catch (Dali::DaliException e) {
17590       {
17591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17592       };
17593     } catch (...) {
17594       {
17595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17596       };
17597     }
17598   }
17599
17600   jresult = result;
17601   return jresult;
17602 }
17603
17604
17605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17606   unsigned int jresult ;
17607   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17608   Dali::Vector4 *arg2 = 0 ;
17609   bool result;
17610
17611   arg1 = (Dali::Property::Value *)jarg1;
17612   arg2 = (Dali::Vector4 *)jarg2;
17613   if (!arg2) {
17614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17615     return 0;
17616   }
17617   {
17618     try {
17619       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17620     } catch (std::out_of_range& e) {
17621       {
17622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17623       };
17624     } catch (std::exception& e) {
17625       {
17626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17627       };
17628     } catch (Dali::DaliException e) {
17629       {
17630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17631       };
17632     } catch (...) {
17633       {
17634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17635       };
17636     }
17637   }
17638
17639   jresult = result;
17640   return jresult;
17641 }
17642
17643
17644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17645   unsigned int jresult ;
17646   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17647   Dali::Matrix3 *arg2 = 0 ;
17648   bool result;
17649
17650   arg1 = (Dali::Property::Value *)jarg1;
17651   arg2 = (Dali::Matrix3 *)jarg2;
17652   if (!arg2) {
17653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17654     return 0;
17655   }
17656   {
17657     try {
17658       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17659     } catch (std::out_of_range& e) {
17660       {
17661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17662       };
17663     } catch (std::exception& e) {
17664       {
17665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17666       };
17667     } catch (Dali::DaliException e) {
17668       {
17669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17670       };
17671     } catch (...) {
17672       {
17673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17674       };
17675     }
17676   }
17677
17678   jresult = result;
17679   return jresult;
17680 }
17681
17682
17683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17684   unsigned int jresult ;
17685   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17686   Dali::Matrix *arg2 = 0 ;
17687   bool result;
17688
17689   arg1 = (Dali::Property::Value *)jarg1;
17690   arg2 = (Dali::Matrix *)jarg2;
17691   if (!arg2) {
17692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17693     return 0;
17694   }
17695   {
17696     try {
17697       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17698     } catch (std::out_of_range& e) {
17699       {
17700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17701       };
17702     } catch (std::exception& e) {
17703       {
17704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17705       };
17706     } catch (Dali::DaliException e) {
17707       {
17708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17709       };
17710     } catch (...) {
17711       {
17712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17713       };
17714     }
17715   }
17716
17717   jresult = result;
17718   return jresult;
17719 }
17720
17721
17722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17723   unsigned int jresult ;
17724   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17725   Dali::AngleAxis *arg2 = 0 ;
17726   bool result;
17727
17728   arg1 = (Dali::Property::Value *)jarg1;
17729   arg2 = (Dali::AngleAxis *)jarg2;
17730   if (!arg2) {
17731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17732     return 0;
17733   }
17734   {
17735     try {
17736       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17737     } catch (std::out_of_range& e) {
17738       {
17739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17740       };
17741     } catch (std::exception& e) {
17742       {
17743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17744       };
17745     } catch (Dali::DaliException e) {
17746       {
17747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17748       };
17749     } catch (...) {
17750       {
17751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17752       };
17753     }
17754   }
17755
17756   jresult = result;
17757   return jresult;
17758 }
17759
17760
17761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17762   unsigned int jresult ;
17763   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17764   Dali::Quaternion *arg2 = 0 ;
17765   bool result;
17766
17767   arg1 = (Dali::Property::Value *)jarg1;
17768   arg2 = (Dali::Quaternion *)jarg2;
17769   if (!arg2) {
17770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17771     return 0;
17772   }
17773   {
17774     try {
17775       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17776     } catch (std::out_of_range& e) {
17777       {
17778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17779       };
17780     } catch (std::exception& e) {
17781       {
17782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17783       };
17784     } catch (Dali::DaliException e) {
17785       {
17786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17787       };
17788     } catch (...) {
17789       {
17790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17791       };
17792     }
17793   }
17794
17795   jresult = result;
17796   return jresult;
17797 }
17798
17799
17800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17801   unsigned int jresult ;
17802   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17803   std::string *arg2 = 0 ;
17804   bool result;
17805
17806   arg1 = (Dali::Property::Value *)jarg1;
17807
17808   //typemap in
17809   std::string temp;
17810   arg2 = &temp;
17811
17812   {
17813     try {
17814       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17815     } catch (std::out_of_range& e) {
17816       {
17817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17818       };
17819     } catch (std::exception& e) {
17820       {
17821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17822       };
17823     } catch (Dali::DaliException e) {
17824       {
17825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17826       };
17827     } catch (...) {
17828       {
17829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17830       };
17831     }
17832   }
17833
17834   jresult = result;
17835
17836   //Typemap argout in c++ file.
17837   //This will convert c++ string to c# string
17838   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17839
17840   return jresult;
17841 }
17842
17843
17844 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17845   unsigned int jresult ;
17846   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17847   Dali::Property::Array *arg2 = 0 ;
17848   bool result;
17849
17850   arg1 = (Dali::Property::Value *)jarg1;
17851   arg2 = (Dali::Property::Array *)jarg2;
17852   if (!arg2) {
17853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17854     return 0;
17855   }
17856   {
17857     try {
17858       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17859     } catch (std::out_of_range& e) {
17860       {
17861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17862       };
17863     } catch (std::exception& e) {
17864       {
17865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17866       };
17867     } catch (Dali::DaliException e) {
17868       {
17869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17870       };
17871     } catch (...) {
17872       {
17873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17874       };
17875     }
17876   }
17877
17878   jresult = result;
17879   return jresult;
17880 }
17881
17882
17883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17884   unsigned int jresult ;
17885   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17886   Dali::Property::Map *arg2 = 0 ;
17887   bool result;
17888
17889   arg1 = (Dali::Property::Value *)jarg1;
17890   arg2 = (Dali::Property::Map *)jarg2;
17891   if (!arg2) {
17892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17893     return 0;
17894   }
17895   {
17896     try {
17897       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17898     } catch (std::out_of_range& e) {
17899       {
17900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17901       };
17902     } catch (std::exception& e) {
17903       {
17904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17905       };
17906     } catch (Dali::DaliException e) {
17907       {
17908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17909       };
17910     } catch (...) {
17911       {
17912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17913       };
17914     }
17915   }
17916
17917   jresult = result;
17918   return jresult;
17919 }
17920
17921
17922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17923   unsigned int jresult ;
17924   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17925   Extents *arg2 = 0 ;
17926   bool result;
17927
17928   arg1 = (Dali::Property::Value *)jarg1;
17929   arg2 = (Extents *)jarg2;
17930   if (!arg2) {
17931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17932     return 0;
17933   }
17934   {
17935     try {
17936       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17937     } catch (std::out_of_range& e) {
17938       {
17939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17940       };
17941     } catch (std::exception& e) {
17942       {
17943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17944       };
17945     } catch (...) {
17946       {
17947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17948       };
17949     }
17950   }
17951   jresult = result;
17952   return jresult;
17953 }
17954
17955
17956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17957   void * jresult ;
17958   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17959   Dali::Property::Array *result = 0 ;
17960
17961   arg1 = (Dali::Property::Value *)jarg1;
17962   {
17963     try {
17964       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17965     } catch (std::out_of_range& e) {
17966       {
17967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17968       };
17969     } catch (std::exception& e) {
17970       {
17971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17972       };
17973     } catch (Dali::DaliException e) {
17974       {
17975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17976       };
17977     } catch (...) {
17978       {
17979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17980       };
17981     }
17982   }
17983
17984   jresult = (void *)result;
17985   return jresult;
17986 }
17987
17988
17989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17990   void * jresult ;
17991   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17992   Dali::Property::Map *result = 0 ;
17993
17994   arg1 = (Dali::Property::Value *)jarg1;
17995   {
17996     try {
17997       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
17998     } catch (std::out_of_range& e) {
17999       {
18000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18001       };
18002     } catch (std::exception& e) {
18003       {
18004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18005       };
18006     } catch (Dali::DaliException e) {
18007       {
18008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18009       };
18010     } catch (...) {
18011       {
18012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18013       };
18014     }
18015   }
18016
18017   jresult = (void *)result;
18018   return jresult;
18019 }
18020
18021
18022 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18023   char * jresult ;
18024   Dali::Property::Type arg1 ;
18025   char *result = 0 ;
18026
18027   arg1 = (Dali::Property::Type)jarg1;
18028   {
18029     try {
18030       result = (char *)Dali::PropertyTypes::GetName(arg1);
18031     } catch (std::out_of_range& e) {
18032       {
18033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18034       };
18035     } catch (std::exception& e) {
18036       {
18037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18038       };
18039     } catch (Dali::DaliException e) {
18040       {
18041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18042       };
18043     } catch (...) {
18044       {
18045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18046       };
18047     }
18048   }
18049
18050   jresult = SWIG_csharp_string_callback((const char *)result);
18051   return jresult;
18052 }
18053
18054
18055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18056   unsigned int jresult ;
18057   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18058   std::string *arg2 = 0 ;
18059   Dali::Property::Map *arg3 = 0 ;
18060   bool result;
18061
18062   arg1 = (Dali::BaseObject *)jarg1;
18063   if (!jarg2) {
18064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18065     return 0;
18066   }
18067   std::string arg2_str(jarg2);
18068   arg2 = &arg2_str;
18069   arg3 = (Dali::Property::Map *)jarg3;
18070   if (!arg3) {
18071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18072     return 0;
18073   }
18074   {
18075     try {
18076       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18077     } catch (std::out_of_range& e) {
18078       {
18079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18080       };
18081     } catch (std::exception& e) {
18082       {
18083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18084       };
18085     } catch (Dali::DaliException e) {
18086       {
18087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18088       };
18089     } catch (...) {
18090       {
18091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18092       };
18093     }
18094   }
18095
18096   jresult = result;
18097
18098   //argout typemap for const std::string&
18099
18100   return jresult;
18101 }
18102
18103
18104 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18105   char * jresult ;
18106   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18107   std::string *result = 0 ;
18108
18109   arg1 = (Dali::BaseObject *)jarg1;
18110   {
18111     try {
18112       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18113     } catch (std::out_of_range& e) {
18114       {
18115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18116       };
18117     } catch (std::exception& e) {
18118       {
18119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18120       };
18121     } catch (Dali::DaliException e) {
18122       {
18123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18124       };
18125     } catch (...) {
18126       {
18127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18128       };
18129     }
18130   }
18131
18132   jresult = SWIG_csharp_string_callback(result->c_str());
18133   return jresult;
18134 }
18135
18136
18137 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18138   unsigned int jresult ;
18139   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18140   Dali::TypeInfo *arg2 = 0 ;
18141   bool result;
18142
18143   arg1 = (Dali::BaseObject *)jarg1;
18144   arg2 = (Dali::TypeInfo *)jarg2;
18145   if (!arg2) {
18146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18147     return 0;
18148   }
18149   {
18150     try {
18151       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18152     } catch (std::out_of_range& e) {
18153       {
18154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18155       };
18156     } catch (std::exception& e) {
18157       {
18158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18159       };
18160     } catch (Dali::DaliException e) {
18161       {
18162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18163       };
18164     } catch (...) {
18165       {
18166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18167       };
18168     }
18169   }
18170
18171   jresult = result;
18172   return jresult;
18173 }
18174
18175
18176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18177   unsigned int jresult ;
18178   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18179   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18180   std::string *arg3 = 0 ;
18181   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18182   bool result;
18183
18184   arg1 = (Dali::BaseObject *)jarg1;
18185   arg2 = (ConnectionTrackerInterface *)jarg2;
18186   if (!jarg3) {
18187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18188     return 0;
18189   }
18190   std::string arg3_str(jarg3);
18191   arg3 = &arg3_str;
18192   arg4 = (FunctorDelegate *)jarg4;
18193   {
18194     try {
18195       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18196     } catch (std::out_of_range& e) {
18197       {
18198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18199       };
18200     } catch (std::exception& e) {
18201       {
18202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18203       };
18204     } catch (Dali::DaliException e) {
18205       {
18206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18207       };
18208     } catch (...) {
18209       {
18210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18211       };
18212     }
18213   }
18214
18215   jresult = result;
18216
18217   //argout typemap for const std::string&
18218
18219   return jresult;
18220 }
18221
18222
18223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18224   void * jresult ;
18225   Dali::BaseHandle *arg1 = 0 ;
18226   Dali::BaseObject *result = 0 ;
18227
18228   arg1 = (Dali::BaseHandle *)jarg1;
18229   if (!arg1) {
18230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18231     return 0;
18232   }
18233   {
18234     try {
18235       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18236     } catch (std::out_of_range& e) {
18237       {
18238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18239       };
18240     } catch (std::exception& e) {
18241       {
18242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18243       };
18244     } catch (Dali::DaliException e) {
18245       {
18246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18247       };
18248     } catch (...) {
18249       {
18250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18251       };
18252     }
18253   }
18254
18255   jresult = (void *)result;
18256   return jresult;
18257 }
18258
18259
18260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18261   void * jresult ;
18262   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18263   Dali::BaseHandle *result = 0 ;
18264
18265   arg1 = (Dali::BaseObject *)jarg1;
18266   {
18267     try {
18268       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18269     } catch (std::out_of_range& e) {
18270       {
18271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18272       };
18273     } catch (std::exception& e) {
18274       {
18275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18276       };
18277     } catch (Dali::DaliException e) {
18278       {
18279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18280       };
18281     } catch (...) {
18282       {
18283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18284       };
18285     }
18286   }
18287
18288   jresult = (void *)result;
18289   return jresult;
18290 }
18291
18292
18293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18294   void * jresult ;
18295   Dali::BaseHandle *result = 0 ;
18296
18297   {
18298     try {
18299       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18300     } catch (std::out_of_range& e) {
18301       {
18302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18303       };
18304     } catch (std::exception& e) {
18305       {
18306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18307       };
18308     } catch (Dali::DaliException e) {
18309       {
18310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18311       };
18312     } catch (...) {
18313       {
18314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18315       };
18316     }
18317   }
18318
18319   jresult = (void *)result;
18320   return jresult;
18321 }
18322
18323
18324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18325   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18326
18327   arg1 = (Dali::BaseHandle *)jarg1;
18328   {
18329     try {
18330       delete arg1;
18331     } catch (std::out_of_range& e) {
18332       {
18333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18334       };
18335     } catch (std::exception& e) {
18336       {
18337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18338       };
18339     } catch (Dali::DaliException e) {
18340       {
18341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18342       };
18343     } catch (...) {
18344       {
18345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18346       };
18347     }
18348   }
18349
18350 }
18351
18352
18353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18354   void * jresult ;
18355   Dali::BaseHandle *arg1 = 0 ;
18356   Dali::BaseHandle *result = 0 ;
18357
18358   arg1 = (Dali::BaseHandle *)jarg1;
18359   if (!arg1) {
18360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18361     return 0;
18362   }
18363   {
18364     try {
18365       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18366     } catch (std::out_of_range& e) {
18367       {
18368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18369       };
18370     } catch (std::exception& e) {
18371       {
18372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18373       };
18374     } catch (Dali::DaliException e) {
18375       {
18376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18377       };
18378     } catch (...) {
18379       {
18380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18381       };
18382     }
18383   }
18384
18385   jresult = (void *)result;
18386   return jresult;
18387 }
18388
18389
18390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18391   void * jresult ;
18392   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18393   Dali::BaseHandle *arg2 = 0 ;
18394   Dali::BaseHandle *result = 0 ;
18395
18396   arg1 = (Dali::BaseHandle *)jarg1;
18397   arg2 = (Dali::BaseHandle *)jarg2;
18398   if (!arg2) {
18399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18400     return 0;
18401   }
18402   {
18403     try {
18404       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18405     } catch (std::out_of_range& e) {
18406       {
18407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18408       };
18409     } catch (std::exception& e) {
18410       {
18411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18412       };
18413     } catch (Dali::DaliException e) {
18414       {
18415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18416       };
18417     } catch (...) {
18418       {
18419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18420       };
18421     }
18422   }
18423
18424   jresult = (void *)result;
18425   return jresult;
18426 }
18427
18428
18429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18430   unsigned int jresult ;
18431   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18432   std::string *arg2 = 0 ;
18433   Dali::Property::Map *arg3 = 0 ;
18434   bool result;
18435
18436   arg1 = (Dali::BaseHandle *)jarg1;
18437   if (!jarg2) {
18438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18439     return 0;
18440   }
18441   std::string arg2_str(jarg2);
18442   arg2 = &arg2_str;
18443   arg3 = (Dali::Property::Map *)jarg3;
18444   if (!arg3) {
18445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18446     return 0;
18447   }
18448   {
18449     try {
18450       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18451     } catch (std::out_of_range& e) {
18452       {
18453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18454       };
18455     } catch (std::exception& e) {
18456       {
18457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18458       };
18459     } catch (Dali::DaliException e) {
18460       {
18461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18462       };
18463     } catch (...) {
18464       {
18465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18466       };
18467     }
18468   }
18469
18470   jresult = result;
18471
18472   //argout typemap for const std::string&
18473
18474   return jresult;
18475 }
18476
18477
18478 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18479   char * jresult ;
18480   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18481   std::string *result = 0 ;
18482
18483   arg1 = (Dali::BaseHandle *)jarg1;
18484   {
18485     try {
18486       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18487     } catch (std::out_of_range& e) {
18488       {
18489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18490       };
18491     } catch (std::exception& e) {
18492       {
18493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18494       };
18495     } catch (Dali::DaliException e) {
18496       {
18497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18498       };
18499     } catch (...) {
18500       {
18501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18502       };
18503     }
18504   }
18505
18506   jresult = SWIG_csharp_string_callback(result->c_str());
18507   return jresult;
18508 }
18509
18510
18511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18512   unsigned int jresult ;
18513   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18514   Dali::TypeInfo *arg2 = 0 ;
18515   bool result;
18516
18517   arg1 = (Dali::BaseHandle *)jarg1;
18518   arg2 = (Dali::TypeInfo *)jarg2;
18519   if (!arg2) {
18520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18521     return 0;
18522   }
18523   {
18524     try {
18525       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18526     } catch (std::out_of_range& e) {
18527       {
18528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18529       };
18530     } catch (std::exception& e) {
18531       {
18532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18533       };
18534     } catch (Dali::DaliException e) {
18535       {
18536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18537       };
18538     } catch (...) {
18539       {
18540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18541       };
18542     }
18543   }
18544
18545   jresult = result;
18546   return jresult;
18547 }
18548
18549
18550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18551   void * jresult ;
18552   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18553   Dali::BaseObject *result = 0 ;
18554
18555   arg1 = (Dali::BaseHandle *)jarg1;
18556   {
18557     try {
18558       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18559     } catch (std::out_of_range& e) {
18560       {
18561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18562       };
18563     } catch (std::exception& e) {
18564       {
18565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18566       };
18567     } catch (Dali::DaliException e) {
18568       {
18569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18570       };
18571     } catch (...) {
18572       {
18573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18574       };
18575     }
18576   }
18577
18578   jresult = (void *)result;
18579   return jresult;
18580 }
18581
18582
18583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18584   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18585
18586   arg1 = (Dali::BaseHandle *)jarg1;
18587   {
18588     try {
18589       (arg1)->Reset();
18590     } catch (std::out_of_range& e) {
18591       {
18592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18593       };
18594     } catch (std::exception& e) {
18595       {
18596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18597       };
18598     } catch (Dali::DaliException e) {
18599       {
18600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18601       };
18602     } catch (...) {
18603       {
18604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18605       };
18606     }
18607   }
18608
18609 }
18610
18611
18612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18613   unsigned int jresult ;
18614   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18615   Dali::BaseHandle *arg2 = 0 ;
18616   bool result;
18617
18618   arg1 = (Dali::BaseHandle *)jarg1;
18619   arg2 = (Dali::BaseHandle *)jarg2;
18620   if (!arg2) {
18621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18622     return 0;
18623   }
18624   {
18625     try {
18626       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18627     } catch (std::out_of_range& e) {
18628       {
18629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18630       };
18631     } catch (std::exception& e) {
18632       {
18633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18634       };
18635     } catch (Dali::DaliException e) {
18636       {
18637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18638       };
18639     } catch (...) {
18640       {
18641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18642       };
18643     }
18644   }
18645
18646   jresult = result;
18647   return jresult;
18648 }
18649
18650
18651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18652   unsigned int jresult ;
18653   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18654   Dali::BaseHandle *arg2 = 0 ;
18655   bool result;
18656
18657   arg1 = (Dali::BaseHandle *)jarg1;
18658   arg2 = (Dali::BaseHandle *)jarg2;
18659   if (!arg2) {
18660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18661     return 0;
18662   }
18663   {
18664     try {
18665       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18666     } catch (std::out_of_range& e) {
18667       {
18668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18669       };
18670     } catch (std::exception& e) {
18671       {
18672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18673       };
18674     } catch (Dali::DaliException e) {
18675       {
18676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18677       };
18678     } catch (...) {
18679       {
18680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18681       };
18682     }
18683   }
18684
18685   jresult = result;
18686   return jresult;
18687 }
18688
18689
18690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18691   void * jresult ;
18692   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18693   Dali::RefObject *result = 0 ;
18694
18695   arg1 = (Dali::BaseHandle *)jarg1;
18696   {
18697     try {
18698       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18699     } catch (std::out_of_range& e) {
18700       {
18701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18702       };
18703     } catch (std::exception& e) {
18704       {
18705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18706       };
18707     } catch (Dali::DaliException e) {
18708       {
18709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18710       };
18711     } catch (...) {
18712       {
18713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18714       };
18715     }
18716   }
18717
18718   jresult = (void *)result;
18719   return jresult;
18720 }
18721
18722
18723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18724   unsigned int jresult ;
18725   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18726   bool result;
18727
18728   arg1 = (Dali::BaseHandle *)jarg1;
18729   {
18730     try {
18731       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18732     } catch (std::out_of_range& e) {
18733       {
18734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18735       };
18736     } catch (std::exception& e) {
18737       {
18738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18739       };
18740     } catch (Dali::DaliException e) {
18741       {
18742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18743       };
18744     } catch (...) {
18745       {
18746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18747       };
18748     }
18749   }
18750
18751   jresult = result;
18752   return jresult;
18753 }
18754
18755
18756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18757   unsigned int jresult ;
18758   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18759   Dali::BaseHandle *arg2 = 0 ;
18760   bool result;
18761
18762   arg1 = (Dali::BaseHandle *)jarg1;
18763   arg2 = (Dali::BaseHandle *)jarg2;
18764   if (!arg2) {
18765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18766     return 0;
18767   }
18768   {
18769     try {
18770       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18771     } catch (std::out_of_range& e) {
18772       {
18773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18774       };
18775     } catch (std::exception& e) {
18776       {
18777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18778       };
18779     } catch (Dali::DaliException e) {
18780       {
18781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18782       };
18783     } catch (...) {
18784       {
18785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18786       };
18787     }
18788   }
18789
18790   jresult = result;
18791   return jresult;
18792 }
18793
18794
18795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18796   unsigned int jresult ;
18797   Dali::BaseHandle *arg1 = 0 ;
18798   Dali::BaseHandle *arg2 = 0 ;
18799   bool result;
18800
18801   arg1 = (Dali::BaseHandle *)jarg1;
18802   if (!arg1) {
18803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18804     return 0;
18805   }
18806   arg2 = (Dali::BaseHandle *)jarg2;
18807   if (!arg2) {
18808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18809     return 0;
18810   }
18811   {
18812     try {
18813       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18814     } catch (std::out_of_range& e) {
18815       {
18816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18817       };
18818     } catch (std::exception& e) {
18819       {
18820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18821       };
18822     } catch (Dali::DaliException e) {
18823       {
18824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18825       };
18826     } catch (...) {
18827       {
18828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18829       };
18830     }
18831   }
18832
18833   jresult = result;
18834   return jresult;
18835 }
18836
18837
18838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18839   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18840
18841   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18842   {
18843     try {
18844       delete arg1;
18845     } catch (std::out_of_range& e) {
18846       {
18847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18848       };
18849     } catch (std::exception& e) {
18850       {
18851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18852       };
18853     } catch (Dali::DaliException e) {
18854       {
18855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18856       };
18857     } catch (...) {
18858       {
18859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18860       };
18861     }
18862   }
18863
18864 }
18865
18866
18867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18868   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18869   SlotObserver *arg2 = (SlotObserver *) 0 ;
18870   CallbackBase *arg3 = (CallbackBase *) 0 ;
18871
18872   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18873   arg2 = (SlotObserver *)jarg2;
18874   arg3 = (CallbackBase *)jarg3;
18875   {
18876     try {
18877       (arg1)->SignalConnected(arg2,arg3);
18878     } catch (std::out_of_range& e) {
18879       {
18880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18881       };
18882     } catch (std::exception& e) {
18883       {
18884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18885       };
18886     } catch (Dali::DaliException e) {
18887       {
18888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18889       };
18890     } catch (...) {
18891       {
18892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18893       };
18894     }
18895   }
18896
18897 }
18898
18899
18900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18901   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18902
18903   arg1 = (Dali::SignalObserver *)jarg1;
18904   {
18905     try {
18906       delete arg1;
18907     } catch (std::out_of_range& e) {
18908       {
18909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18910       };
18911     } catch (std::exception& e) {
18912       {
18913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18914       };
18915     } catch (Dali::DaliException e) {
18916       {
18917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18918       };
18919     } catch (...) {
18920       {
18921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18922       };
18923     }
18924   }
18925
18926 }
18927
18928
18929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18930   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18931   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18932   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18933
18934   arg1 = (Dali::SignalObserver *)jarg1;
18935   arg2 = (Dali::SlotObserver *)jarg2;
18936   arg3 = (Dali::CallbackBase *)jarg3;
18937   {
18938     try {
18939       (arg1)->SignalDisconnected(arg2,arg3);
18940     } catch (std::out_of_range& e) {
18941       {
18942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18943       };
18944     } catch (std::exception& e) {
18945       {
18946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18947       };
18948     } catch (Dali::DaliException e) {
18949       {
18950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18951       };
18952     } catch (...) {
18953       {
18954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18955       };
18956     }
18957   }
18958
18959 }
18960
18961
18962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18963   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18964
18965   arg1 = (Dali::SlotObserver *)jarg1;
18966   {
18967     try {
18968       delete arg1;
18969     } catch (std::out_of_range& e) {
18970       {
18971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18972       };
18973     } catch (std::exception& e) {
18974       {
18975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18976       };
18977     } catch (Dali::DaliException e) {
18978       {
18979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18980       };
18981     } catch (...) {
18982       {
18983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18984       };
18985     }
18986   }
18987
18988 }
18989
18990
18991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
18992   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18993   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
18994
18995   arg1 = (Dali::SlotObserver *)jarg1;
18996   arg2 = (Dali::CallbackBase *)jarg2;
18997   {
18998     try {
18999       (arg1)->SlotDisconnected(arg2);
19000     } catch (std::out_of_range& e) {
19001       {
19002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19003       };
19004     } catch (std::exception& e) {
19005       {
19006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19007       };
19008     } catch (Dali::DaliException e) {
19009       {
19010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19011       };
19012     } catch (...) {
19013       {
19014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19015       };
19016     }
19017   }
19018
19019 }
19020
19021
19022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19023   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19024
19025   arg1 = (Dali::ConnectionTracker *)jarg1;
19026   {
19027     try {
19028       delete arg1;
19029     } catch (std::out_of_range& e) {
19030       {
19031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19032       };
19033     } catch (std::exception& e) {
19034       {
19035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19036       };
19037     } catch (Dali::DaliException e) {
19038       {
19039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19040       };
19041     } catch (...) {
19042       {
19043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19044       };
19045     }
19046   }
19047
19048 }
19049
19050
19051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19052   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19053
19054   arg1 = (Dali::ConnectionTracker *)jarg1;
19055   {
19056     try {
19057       (arg1)->DisconnectAll();
19058     } catch (std::out_of_range& e) {
19059       {
19060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19061       };
19062     } catch (std::exception& e) {
19063       {
19064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19065       };
19066     } catch (Dali::DaliException e) {
19067       {
19068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19069       };
19070     } catch (...) {
19071       {
19072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19073       };
19074     }
19075   }
19076
19077 }
19078
19079
19080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19081   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19082   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19083   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19084
19085   arg1 = (Dali::ConnectionTracker *)jarg1;
19086   arg2 = (Dali::SlotObserver *)jarg2;
19087   arg3 = (Dali::CallbackBase *)jarg3;
19088   {
19089     try {
19090       (arg1)->SignalConnected(arg2,arg3);
19091     } catch (std::out_of_range& e) {
19092       {
19093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19094       };
19095     } catch (std::exception& e) {
19096       {
19097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19098       };
19099     } catch (Dali::DaliException e) {
19100       {
19101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19102       };
19103     } catch (...) {
19104       {
19105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19106       };
19107     }
19108   }
19109
19110 }
19111
19112
19113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19114   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19115   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19116   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19117
19118   arg1 = (Dali::ConnectionTracker *)jarg1;
19119   arg2 = (Dali::SlotObserver *)jarg2;
19120   arg3 = (Dali::CallbackBase *)jarg3;
19121   {
19122     try {
19123       (arg1)->SignalDisconnected(arg2,arg3);
19124     } catch (std::out_of_range& e) {
19125       {
19126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19127       };
19128     } catch (std::exception& e) {
19129       {
19130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19131       };
19132     } catch (Dali::DaliException e) {
19133       {
19134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19135       };
19136     } catch (...) {
19137       {
19138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19139       };
19140     }
19141   }
19142
19143 }
19144
19145
19146 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19147   unsigned long jresult ;
19148   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19149   std::size_t result;
19150
19151   arg1 = (Dali::ConnectionTracker *)jarg1;
19152   {
19153     try {
19154       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19155     } catch (std::out_of_range& e) {
19156       {
19157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19158       };
19159     } catch (std::exception& e) {
19160       {
19161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19162       };
19163     } catch (Dali::DaliException e) {
19164       {
19165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19166       };
19167     } catch (...) {
19168       {
19169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19170       };
19171     }
19172   }
19173
19174   jresult = (unsigned long)result;
19175   return jresult;
19176 }
19177
19178
19179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19180   void * jresult ;
19181   Dali::ObjectRegistry *result = 0 ;
19182
19183   {
19184     try {
19185       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19186     } catch (std::out_of_range& e) {
19187       {
19188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19189       };
19190     } catch (std::exception& e) {
19191       {
19192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19193       };
19194     } catch (Dali::DaliException e) {
19195       {
19196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19197       };
19198     } catch (...) {
19199       {
19200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19201       };
19202     }
19203   }
19204
19205   jresult = (void *)result;
19206   return jresult;
19207 }
19208
19209
19210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19211   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19212
19213   arg1 = (Dali::ObjectRegistry *)jarg1;
19214   {
19215     try {
19216       delete arg1;
19217     } catch (std::out_of_range& e) {
19218       {
19219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19220       };
19221     } catch (std::exception& e) {
19222       {
19223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19224       };
19225     } catch (Dali::DaliException e) {
19226       {
19227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19228       };
19229     } catch (...) {
19230       {
19231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19232       };
19233     }
19234   }
19235
19236 }
19237
19238
19239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19240   void * jresult ;
19241   Dali::ObjectRegistry *arg1 = 0 ;
19242   Dali::ObjectRegistry *result = 0 ;
19243
19244   arg1 = (Dali::ObjectRegistry *)jarg1;
19245   if (!arg1) {
19246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19247     return 0;
19248   }
19249   {
19250     try {
19251       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19252     } catch (std::out_of_range& e) {
19253       {
19254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19255       };
19256     } catch (std::exception& e) {
19257       {
19258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19259       };
19260     } catch (Dali::DaliException e) {
19261       {
19262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19263       };
19264     } catch (...) {
19265       {
19266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19267       };
19268     }
19269   }
19270
19271   jresult = (void *)result;
19272   return jresult;
19273 }
19274
19275
19276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19277   void * jresult ;
19278   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19279   Dali::ObjectRegistry *arg2 = 0 ;
19280   Dali::ObjectRegistry *result = 0 ;
19281
19282   arg1 = (Dali::ObjectRegistry *)jarg1;
19283   arg2 = (Dali::ObjectRegistry *)jarg2;
19284   if (!arg2) {
19285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19286     return 0;
19287   }
19288   {
19289     try {
19290       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19291     } catch (std::out_of_range& e) {
19292       {
19293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19294       };
19295     } catch (std::exception& e) {
19296       {
19297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19298       };
19299     } catch (Dali::DaliException e) {
19300       {
19301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19302       };
19303     } catch (...) {
19304       {
19305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19306       };
19307     }
19308   }
19309
19310   jresult = (void *)result;
19311   return jresult;
19312 }
19313
19314
19315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19316   void * jresult ;
19317   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19318   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19319
19320   arg1 = (Dali::ObjectRegistry *)jarg1;
19321   {
19322     try {
19323       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19324     } catch (std::out_of_range& e) {
19325       {
19326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19327       };
19328     } catch (std::exception& e) {
19329       {
19330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19331       };
19332     } catch (Dali::DaliException e) {
19333       {
19334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19335       };
19336     } catch (...) {
19337       {
19338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19339       };
19340     }
19341   }
19342
19343   jresult = (void *)result;
19344   return jresult;
19345 }
19346
19347
19348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19349   void * jresult ;
19350   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19351   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19352
19353   arg1 = (Dali::ObjectRegistry *)jarg1;
19354   {
19355     try {
19356       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19357     } catch (std::out_of_range& e) {
19358       {
19359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19360       };
19361     } catch (std::exception& e) {
19362       {
19363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19364       };
19365     } catch (Dali::DaliException e) {
19366       {
19367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19368       };
19369     } catch (...) {
19370       {
19371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19372       };
19373     }
19374   }
19375
19376   jresult = (void *)result;
19377   return jresult;
19378 }
19379
19380
19381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19382   void * jresult ;
19383   Dali::PropertyCondition *result = 0 ;
19384
19385   {
19386     try {
19387       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19388     } catch (std::out_of_range& e) {
19389       {
19390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19391       };
19392     } catch (std::exception& e) {
19393       {
19394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19395       };
19396     } catch (Dali::DaliException e) {
19397       {
19398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19399       };
19400     } catch (...) {
19401       {
19402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19403       };
19404     }
19405   }
19406
19407   jresult = (void *)result;
19408   return jresult;
19409 }
19410
19411
19412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19413   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19414
19415   arg1 = (Dali::PropertyCondition *)jarg1;
19416   {
19417     try {
19418       delete arg1;
19419     } catch (std::out_of_range& e) {
19420       {
19421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19422       };
19423     } catch (std::exception& e) {
19424       {
19425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19426       };
19427     } catch (Dali::DaliException e) {
19428       {
19429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19430       };
19431     } catch (...) {
19432       {
19433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19434       };
19435     }
19436   }
19437
19438 }
19439
19440
19441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19442   void * jresult ;
19443   Dali::PropertyCondition *arg1 = 0 ;
19444   Dali::PropertyCondition *result = 0 ;
19445
19446   arg1 = (Dali::PropertyCondition *)jarg1;
19447   if (!arg1) {
19448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19449     return 0;
19450   }
19451   {
19452     try {
19453       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19454     } catch (std::out_of_range& e) {
19455       {
19456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19457       };
19458     } catch (std::exception& e) {
19459       {
19460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19461       };
19462     } catch (Dali::DaliException e) {
19463       {
19464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19465       };
19466     } catch (...) {
19467       {
19468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19469       };
19470     }
19471   }
19472
19473   jresult = (void *)result;
19474   return jresult;
19475 }
19476
19477
19478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19479   void * jresult ;
19480   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19481   Dali::PropertyCondition *arg2 = 0 ;
19482   Dali::PropertyCondition *result = 0 ;
19483
19484   arg1 = (Dali::PropertyCondition *)jarg1;
19485   arg2 = (Dali::PropertyCondition *)jarg2;
19486   if (!arg2) {
19487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19488     return 0;
19489   }
19490   {
19491     try {
19492       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19493     } catch (std::out_of_range& e) {
19494       {
19495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19496       };
19497     } catch (std::exception& e) {
19498       {
19499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19500       };
19501     } catch (Dali::DaliException e) {
19502       {
19503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19504       };
19505     } catch (...) {
19506       {
19507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19508       };
19509     }
19510   }
19511
19512   jresult = (void *)result;
19513   return jresult;
19514 }
19515
19516
19517 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19518   unsigned long jresult ;
19519   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19520   std::size_t result;
19521
19522   arg1 = (Dali::PropertyCondition *)jarg1;
19523   {
19524     try {
19525       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19526     } catch (std::out_of_range& e) {
19527       {
19528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19529       };
19530     } catch (std::exception& e) {
19531       {
19532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19533       };
19534     } catch (...) {
19535       {
19536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19537       };
19538     }
19539   }
19540   jresult = (unsigned long)result;
19541   return jresult;
19542 }
19543
19544
19545 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19546   float jresult ;
19547   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19548   std::size_t arg2 ;
19549   float result;
19550
19551   arg1 = (Dali::PropertyCondition *)jarg1;
19552   arg2 = (std::size_t)jarg2;
19553   {
19554     try {
19555       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19556     } catch (std::out_of_range& e) {
19557       {
19558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19559       };
19560     } catch (std::exception& e) {
19561       {
19562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19563       };
19564     } catch (...) {
19565       {
19566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19567       };
19568     }
19569   }
19570   jresult = result;
19571   return jresult;
19572 }
19573
19574
19575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19576   void * jresult ;
19577   float arg1 ;
19578   Dali::PropertyCondition result;
19579
19580   arg1 = (float)jarg1;
19581   {
19582     try {
19583       result = Dali::LessThanCondition(arg1);
19584     } catch (std::out_of_range& e) {
19585       {
19586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19587       };
19588     } catch (std::exception& e) {
19589       {
19590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19591       };
19592     } catch (Dali::DaliException e) {
19593       {
19594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19595       };
19596     } catch (...) {
19597       {
19598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19599       };
19600     }
19601   }
19602
19603   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19604   return jresult;
19605 }
19606
19607
19608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19609   void * jresult ;
19610   float arg1 ;
19611   Dali::PropertyCondition result;
19612
19613   arg1 = (float)jarg1;
19614   {
19615     try {
19616       result = Dali::GreaterThanCondition(arg1);
19617     } catch (std::out_of_range& e) {
19618       {
19619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19620       };
19621     } catch (std::exception& e) {
19622       {
19623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19624       };
19625     } catch (Dali::DaliException e) {
19626       {
19627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19628       };
19629     } catch (...) {
19630       {
19631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19632       };
19633     }
19634   }
19635
19636   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19637   return jresult;
19638 }
19639
19640
19641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19642   void * jresult ;
19643   float arg1 ;
19644   float arg2 ;
19645   Dali::PropertyCondition result;
19646
19647   arg1 = (float)jarg1;
19648   arg2 = (float)jarg2;
19649   {
19650     try {
19651       result = Dali::InsideCondition(arg1,arg2);
19652     } catch (std::out_of_range& e) {
19653       {
19654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19655       };
19656     } catch (std::exception& e) {
19657       {
19658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19659       };
19660     } catch (Dali::DaliException e) {
19661       {
19662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19663       };
19664     } catch (...) {
19665       {
19666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19667       };
19668     }
19669   }
19670
19671   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19672   return jresult;
19673 }
19674
19675
19676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19677   void * jresult ;
19678   float arg1 ;
19679   float arg2 ;
19680   Dali::PropertyCondition result;
19681
19682   arg1 = (float)jarg1;
19683   arg2 = (float)jarg2;
19684   {
19685     try {
19686       result = Dali::OutsideCondition(arg1,arg2);
19687     } catch (std::out_of_range& e) {
19688       {
19689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19690       };
19691     } catch (std::exception& e) {
19692       {
19693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19694       };
19695     } catch (Dali::DaliException e) {
19696       {
19697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19698       };
19699     } catch (...) {
19700       {
19701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19702       };
19703     }
19704   }
19705
19706   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19707   return jresult;
19708 }
19709
19710
19711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19712   void * jresult ;
19713   float arg1 ;
19714   float arg2 ;
19715   Dali::PropertyCondition result;
19716
19717   arg1 = (float)jarg1;
19718   arg2 = (float)jarg2;
19719   {
19720     try {
19721       result = Dali::StepCondition(arg1,arg2);
19722     } catch (std::out_of_range& e) {
19723       {
19724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19725       };
19726     } catch (std::exception& e) {
19727       {
19728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19729       };
19730     } catch (Dali::DaliException e) {
19731       {
19732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19733       };
19734     } catch (...) {
19735       {
19736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19737       };
19738     }
19739   }
19740
19741   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19742   return jresult;
19743 }
19744
19745
19746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19747   void * jresult ;
19748   float arg1 ;
19749   Dali::PropertyCondition result;
19750
19751   arg1 = (float)jarg1;
19752   {
19753     try {
19754       result = Dali::StepCondition(arg1);
19755     } catch (std::out_of_range& e) {
19756       {
19757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19758       };
19759     } catch (std::exception& e) {
19760       {
19761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19762       };
19763     } catch (Dali::DaliException e) {
19764       {
19765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19766       };
19767     } catch (...) {
19768       {
19769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19770       };
19771     }
19772   }
19773
19774   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19775   return jresult;
19776 }
19777
19778
19779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19780   void * jresult ;
19781   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19782   Dali::PropertyCondition result;
19783
19784   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19785   if (!arg1) {
19786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19787     return 0;
19788   }
19789   {
19790     try {
19791       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19792     } catch (std::out_of_range& e) {
19793       {
19794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19795       };
19796     } catch (std::exception& e) {
19797       {
19798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19799       };
19800     } catch (Dali::DaliException e) {
19801       {
19802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19803       };
19804     } catch (...) {
19805       {
19806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19807       };
19808     }
19809   }
19810
19811   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19812   return jresult;
19813 }
19814
19815
19816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19817   void * jresult ;
19818   Dali::PropertyNotification *result = 0 ;
19819
19820   {
19821     try {
19822       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19823     } catch (std::out_of_range& e) {
19824       {
19825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19826       };
19827     } catch (std::exception& e) {
19828       {
19829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19830       };
19831     } catch (Dali::DaliException e) {
19832       {
19833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19834       };
19835     } catch (...) {
19836       {
19837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19838       };
19839     }
19840   }
19841
19842   jresult = (void *)result;
19843   return jresult;
19844 }
19845
19846
19847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19848   void * jresult ;
19849   Dali::BaseHandle arg1 ;
19850   Dali::BaseHandle *argp1 ;
19851   Dali::PropertyNotification result;
19852
19853   argp1 = (Dali::BaseHandle *)jarg1;
19854   if (!argp1) {
19855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19856     return 0;
19857   }
19858   arg1 = *argp1;
19859   {
19860     try {
19861       result = Dali::PropertyNotification::DownCast(arg1);
19862     } catch (std::out_of_range& e) {
19863       {
19864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19865       };
19866     } catch (std::exception& e) {
19867       {
19868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19869       };
19870     } catch (Dali::DaliException e) {
19871       {
19872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19873       };
19874     } catch (...) {
19875       {
19876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19877       };
19878     }
19879   }
19880
19881   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19882   return jresult;
19883 }
19884
19885
19886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19887   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19888
19889   arg1 = (Dali::PropertyNotification *)jarg1;
19890   {
19891     try {
19892       delete arg1;
19893     } catch (std::out_of_range& e) {
19894       {
19895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19896       };
19897     } catch (std::exception& e) {
19898       {
19899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19900       };
19901     } catch (Dali::DaliException e) {
19902       {
19903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19904       };
19905     } catch (...) {
19906       {
19907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19908       };
19909     }
19910   }
19911
19912 }
19913
19914
19915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19916   void * jresult ;
19917   Dali::PropertyNotification *arg1 = 0 ;
19918   Dali::PropertyNotification *result = 0 ;
19919
19920   arg1 = (Dali::PropertyNotification *)jarg1;
19921   if (!arg1) {
19922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19923     return 0;
19924   }
19925   {
19926     try {
19927       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19928     } catch (std::out_of_range& e) {
19929       {
19930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19931       };
19932     } catch (std::exception& e) {
19933       {
19934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19935       };
19936     } catch (Dali::DaliException e) {
19937       {
19938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19939       };
19940     } catch (...) {
19941       {
19942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19943       };
19944     }
19945   }
19946
19947   jresult = (void *)result;
19948   return jresult;
19949 }
19950
19951
19952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19953   void * jresult ;
19954   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19955   Dali::PropertyNotification *arg2 = 0 ;
19956   Dali::PropertyNotification *result = 0 ;
19957
19958   arg1 = (Dali::PropertyNotification *)jarg1;
19959   arg2 = (Dali::PropertyNotification *)jarg2;
19960   if (!arg2) {
19961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19962     return 0;
19963   }
19964   {
19965     try {
19966       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19967     } catch (std::out_of_range& e) {
19968       {
19969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19970       };
19971     } catch (std::exception& e) {
19972       {
19973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19974       };
19975     } catch (Dali::DaliException e) {
19976       {
19977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19978       };
19979     } catch (...) {
19980       {
19981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19982       };
19983     }
19984   }
19985
19986   jresult = (void *)result;
19987   return jresult;
19988 }
19989
19990
19991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
19992   void * jresult ;
19993   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19994   Dali::PropertyCondition result;
19995
19996   arg1 = (Dali::PropertyNotification *)jarg1;
19997   {
19998     try {
19999       result = (arg1)->GetCondition();
20000     } catch (std::out_of_range& e) {
20001       {
20002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20003       };
20004     } catch (std::exception& e) {
20005       {
20006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20007       };
20008     } catch (Dali::DaliException e) {
20009       {
20010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20011       };
20012     } catch (...) {
20013       {
20014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20015       };
20016     }
20017   }
20018
20019   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20020   return jresult;
20021 }
20022
20023
20024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20025   void * jresult ;
20026   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20027   Dali::Handle result;
20028
20029   arg1 = (Dali::PropertyNotification *)jarg1;
20030   {
20031     try {
20032       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20033     } catch (std::out_of_range& e) {
20034       {
20035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20036       };
20037     } catch (std::exception& e) {
20038       {
20039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20040       };
20041     } catch (Dali::DaliException e) {
20042       {
20043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20044       };
20045     } catch (...) {
20046       {
20047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20048       };
20049     }
20050   }
20051
20052   jresult = new Dali::Handle((const Dali::Handle &)result);
20053   return jresult;
20054 }
20055
20056
20057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20058   int jresult ;
20059   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20060   Dali::Property::Index result;
20061
20062   arg1 = (Dali::PropertyNotification *)jarg1;
20063   {
20064     try {
20065       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20066     } catch (std::out_of_range& e) {
20067       {
20068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20069       };
20070     } catch (std::exception& e) {
20071       {
20072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20073       };
20074     } catch (Dali::DaliException e) {
20075       {
20076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20077       };
20078     } catch (...) {
20079       {
20080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20081       };
20082     }
20083   }
20084
20085   jresult = result;
20086   return jresult;
20087 }
20088
20089
20090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20091   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20092   Dali::PropertyNotification::NotifyMode arg2 ;
20093
20094   arg1 = (Dali::PropertyNotification *)jarg1;
20095   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20096   {
20097     try {
20098       (arg1)->SetNotifyMode(arg2);
20099     } catch (std::out_of_range& e) {
20100       {
20101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20102       };
20103     } catch (std::exception& e) {
20104       {
20105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20106       };
20107     } catch (Dali::DaliException e) {
20108       {
20109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20110       };
20111     } catch (...) {
20112       {
20113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20114       };
20115     }
20116   }
20117
20118 }
20119
20120
20121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20122   int jresult ;
20123   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20124   Dali::PropertyNotification::NotifyMode result;
20125
20126   arg1 = (Dali::PropertyNotification *)jarg1;
20127   {
20128     try {
20129       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20130     } catch (std::out_of_range& e) {
20131       {
20132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20133       };
20134     } catch (std::exception& e) {
20135       {
20136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20137       };
20138     } catch (Dali::DaliException e) {
20139       {
20140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20141       };
20142     } catch (...) {
20143       {
20144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20145       };
20146     }
20147   }
20148
20149   jresult = (int)result;
20150   return jresult;
20151 }
20152
20153
20154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20155   unsigned int jresult ;
20156   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20157   bool result;
20158
20159   arg1 = (Dali::PropertyNotification *)jarg1;
20160   {
20161     try {
20162       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20163     } catch (std::out_of_range& e) {
20164       {
20165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20166       };
20167     } catch (std::exception& e) {
20168       {
20169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20170       };
20171     } catch (Dali::DaliException e) {
20172       {
20173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20174       };
20175     } catch (...) {
20176       {
20177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20178       };
20179     }
20180   }
20181
20182   jresult = result;
20183   return jresult;
20184 }
20185
20186
20187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20188   void * jresult ;
20189   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20190   Dali::PropertyNotifySignalType *result = 0 ;
20191
20192   arg1 = (Dali::PropertyNotification *)jarg1;
20193   {
20194     try {
20195       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20196     } catch (std::out_of_range& e) {
20197       {
20198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20199       };
20200     } catch (std::exception& e) {
20201       {
20202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20203       };
20204     } catch (Dali::DaliException e) {
20205       {
20206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20207       };
20208     } catch (...) {
20209       {
20210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20211       };
20212     }
20213   }
20214
20215   jresult = (void *)result;
20216   return jresult;
20217 }
20218
20219
20220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20221   void * jresult ;
20222   Dali::Handle *result = 0 ;
20223
20224   {
20225     try {
20226       result = (Dali::Handle *)new Dali::Handle();
20227     } catch (std::out_of_range& e) {
20228       {
20229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20230       };
20231     } catch (std::exception& e) {
20232       {
20233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20234       };
20235     } catch (Dali::DaliException e) {
20236       {
20237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20238       };
20239     } catch (...) {
20240       {
20241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20242       };
20243     }
20244   }
20245
20246   jresult = (void *)result;
20247   return jresult;
20248 }
20249
20250
20251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20252   void * jresult ;
20253   Dali::Handle result;
20254
20255   {
20256     try {
20257       result = Dali::Handle::New();
20258     } catch (std::out_of_range& e) {
20259       {
20260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20261       };
20262     } catch (std::exception& e) {
20263       {
20264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20265       };
20266     } catch (Dali::DaliException e) {
20267       {
20268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20269       };
20270     } catch (...) {
20271       {
20272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20273       };
20274     }
20275   }
20276
20277   jresult = new Dali::Handle((const Dali::Handle &)result);
20278   return jresult;
20279 }
20280
20281
20282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20283   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20284
20285   arg1 = (Dali::Handle *)jarg1;
20286   {
20287     try {
20288       delete arg1;
20289     } catch (std::out_of_range& e) {
20290       {
20291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20292       };
20293     } catch (std::exception& e) {
20294       {
20295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20296       };
20297     } catch (Dali::DaliException e) {
20298       {
20299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20300       };
20301     } catch (...) {
20302       {
20303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20304       };
20305     }
20306   }
20307
20308 }
20309
20310
20311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20312   void * jresult ;
20313   Dali::Handle *arg1 = 0 ;
20314   Dali::Handle *result = 0 ;
20315
20316   arg1 = (Dali::Handle *)jarg1;
20317   if (!arg1) {
20318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20319     return 0;
20320   }
20321   {
20322     try {
20323       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20324     } catch (std::out_of_range& e) {
20325       {
20326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20327       };
20328     } catch (std::exception& e) {
20329       {
20330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20331       };
20332     } catch (Dali::DaliException e) {
20333       {
20334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20335       };
20336     } catch (...) {
20337       {
20338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20339       };
20340     }
20341   }
20342
20343   jresult = (void *)result;
20344   return jresult;
20345 }
20346
20347
20348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20349   void * jresult ;
20350   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20351   Dali::Handle *arg2 = 0 ;
20352   Dali::Handle *result = 0 ;
20353
20354   arg1 = (Dali::Handle *)jarg1;
20355   arg2 = (Dali::Handle *)jarg2;
20356   if (!arg2) {
20357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20358     return 0;
20359   }
20360   {
20361     try {
20362       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20363     } catch (std::out_of_range& e) {
20364       {
20365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20366       };
20367     } catch (std::exception& e) {
20368       {
20369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20370       };
20371     } catch (Dali::DaliException e) {
20372       {
20373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20374       };
20375     } catch (...) {
20376       {
20377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20378       };
20379     }
20380   }
20381
20382   jresult = (void *)result;
20383   return jresult;
20384 }
20385
20386
20387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20388   void * jresult ;
20389   Dali::BaseHandle arg1 ;
20390   Dali::BaseHandle *argp1 ;
20391   Dali::Handle result;
20392
20393   argp1 = (Dali::BaseHandle *)jarg1;
20394   if (!argp1) {
20395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20396     return 0;
20397   }
20398   arg1 = *argp1;
20399   {
20400     try {
20401       result = Dali::Handle::DownCast(arg1);
20402     } catch (std::out_of_range& e) {
20403       {
20404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20405       };
20406     } catch (std::exception& e) {
20407       {
20408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20409       };
20410     } catch (Dali::DaliException e) {
20411       {
20412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20413       };
20414     } catch (...) {
20415       {
20416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20417       };
20418     }
20419   }
20420
20421   jresult = new Dali::Handle((const Dali::Handle &)result);
20422   return jresult;
20423 }
20424
20425
20426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20427   unsigned int jresult ;
20428   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20429   Dali::Handle::Capability arg2 ;
20430   bool result;
20431
20432   arg1 = (Dali::Handle *)jarg1;
20433   arg2 = (Dali::Handle::Capability)jarg2;
20434   {
20435     try {
20436       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20437     } catch (std::out_of_range& e) {
20438       {
20439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20440       };
20441     } catch (std::exception& e) {
20442       {
20443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20444       };
20445     } catch (Dali::DaliException e) {
20446       {
20447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20448       };
20449     } catch (...) {
20450       {
20451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20452       };
20453     }
20454   }
20455
20456   jresult = result;
20457   return jresult;
20458 }
20459
20460
20461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20462   unsigned int jresult ;
20463   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20464   unsigned int result;
20465
20466   arg1 = (Dali::Handle *)jarg1;
20467   {
20468     try {
20469       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20470     } catch (std::out_of_range& e) {
20471       {
20472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20473       };
20474     } catch (std::exception& e) {
20475       {
20476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20477       };
20478     } catch (Dali::DaliException e) {
20479       {
20480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20481       };
20482     } catch (...) {
20483       {
20484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20485       };
20486     }
20487   }
20488
20489   jresult = result;
20490   return jresult;
20491 }
20492
20493
20494 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20495   char * jresult ;
20496   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20497   Dali::Property::Index arg2 ;
20498   std::string result;
20499
20500   arg1 = (Dali::Handle *)jarg1;
20501   arg2 = (Dali::Property::Index)jarg2;
20502   {
20503     try {
20504       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20505     } catch (std::out_of_range& e) {
20506       {
20507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20508       };
20509     } catch (std::exception& e) {
20510       {
20511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20512       };
20513     } catch (Dali::DaliException e) {
20514       {
20515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20516       };
20517     } catch (...) {
20518       {
20519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20520       };
20521     }
20522   }
20523
20524   jresult = SWIG_csharp_string_callback((&result)->c_str());
20525   return jresult;
20526 }
20527
20528
20529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20530   int jresult ;
20531   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20532   std::string *arg2 = 0 ;
20533   Dali::Property::Index result;
20534
20535   arg1 = (Dali::Handle *)jarg1;
20536   if (!jarg2) {
20537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20538     return 0;
20539   }
20540   std::string arg2_str(jarg2);
20541   arg2 = &arg2_str;
20542   {
20543     try {
20544       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20545     } catch (std::out_of_range& e) {
20546       {
20547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20548       };
20549     } catch (std::exception& e) {
20550       {
20551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20552       };
20553     } catch (Dali::DaliException e) {
20554       {
20555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20556       };
20557     } catch (...) {
20558       {
20559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20560       };
20561     }
20562   }
20563
20564   jresult = result;
20565
20566   //argout typemap for const std::string&
20567
20568   return jresult;
20569 }
20570
20571
20572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20573   unsigned int jresult ;
20574   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20575   Dali::Property::Index arg2 ;
20576   bool result;
20577
20578   arg1 = (Dali::Handle *)jarg1;
20579   arg2 = (Dali::Property::Index)jarg2;
20580   {
20581     try {
20582       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20583     } catch (std::out_of_range& e) {
20584       {
20585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20586       };
20587     } catch (std::exception& e) {
20588       {
20589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20590       };
20591     } catch (Dali::DaliException e) {
20592       {
20593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20594       };
20595     } catch (...) {
20596       {
20597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20598       };
20599     }
20600   }
20601
20602   jresult = result;
20603   return jresult;
20604 }
20605
20606
20607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20608   unsigned int jresult ;
20609   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20610   Dali::Property::Index arg2 ;
20611   bool result;
20612
20613   arg1 = (Dali::Handle *)jarg1;
20614   arg2 = (Dali::Property::Index)jarg2;
20615   {
20616     try {
20617       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20618     } catch (std::out_of_range& e) {
20619       {
20620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20621       };
20622     } catch (std::exception& e) {
20623       {
20624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20625       };
20626     } catch (Dali::DaliException e) {
20627       {
20628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20629       };
20630     } catch (...) {
20631       {
20632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20633       };
20634     }
20635   }
20636
20637   jresult = result;
20638   return jresult;
20639 }
20640
20641
20642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20643   unsigned int jresult ;
20644   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20645   Dali::Property::Index arg2 ;
20646   bool result;
20647
20648   arg1 = (Dali::Handle *)jarg1;
20649   arg2 = (Dali::Property::Index)jarg2;
20650   {
20651     try {
20652       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20653     } catch (std::out_of_range& e) {
20654       {
20655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20656       };
20657     } catch (std::exception& e) {
20658       {
20659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20660       };
20661     } catch (Dali::DaliException e) {
20662       {
20663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20664       };
20665     } catch (...) {
20666       {
20667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20668       };
20669     }
20670   }
20671
20672   jresult = result;
20673   return jresult;
20674 }
20675
20676
20677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20678   int jresult ;
20679   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20680   Dali::Property::Index arg2 ;
20681   Dali::Property::Type result;
20682
20683   arg1 = (Dali::Handle *)jarg1;
20684   arg2 = (Dali::Property::Index)jarg2;
20685   {
20686     try {
20687       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20688     } catch (std::out_of_range& e) {
20689       {
20690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20691       };
20692     } catch (std::exception& e) {
20693       {
20694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20695       };
20696     } catch (Dali::DaliException e) {
20697       {
20698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20699       };
20700     } catch (...) {
20701       {
20702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20703       };
20704     }
20705   }
20706
20707   jresult = (int)result;
20708   return jresult;
20709 }
20710
20711
20712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20713   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20714   Dali::Property::Index arg2 ;
20715   Dali::Property::Value *arg3 = 0 ;
20716
20717   arg1 = (Dali::Handle *)jarg1;
20718   arg2 = (Dali::Property::Index)jarg2;
20719   arg3 = (Dali::Property::Value *)jarg3;
20720   if (!arg3) {
20721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20722     return ;
20723   }
20724   {
20725     try {
20726       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20727     } catch (std::out_of_range& e) {
20728       {
20729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20730       };
20731     } catch (std::exception& e) {
20732       {
20733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20734       };
20735     } catch (Dali::DaliException e) {
20736       {
20737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20738       };
20739     } catch (...) {
20740       {
20741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20742       };
20743     }
20744   }
20745
20746 }
20747
20748
20749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20750   int jresult ;
20751   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20752   std::string *arg2 = 0 ;
20753   Dali::Property::Value *arg3 = 0 ;
20754   Dali::Property::Index result;
20755
20756   arg1 = (Dali::Handle *)jarg1;
20757   if (!jarg2) {
20758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20759     return 0;
20760   }
20761   std::string arg2_str(jarg2);
20762   arg2 = &arg2_str;
20763   arg3 = (Dali::Property::Value *)jarg3;
20764   if (!arg3) {
20765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20766     return 0;
20767   }
20768   {
20769     try {
20770       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20771     } catch (std::out_of_range& e) {
20772       {
20773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20774       };
20775     } catch (std::exception& e) {
20776       {
20777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20778       };
20779     } catch (Dali::DaliException e) {
20780       {
20781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20782       };
20783     } catch (...) {
20784       {
20785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20786       };
20787     }
20788   }
20789
20790   jresult = result;
20791
20792   //argout typemap for const std::string&
20793
20794   return jresult;
20795 }
20796
20797
20798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20799   int jresult ;
20800   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20801   std::string *arg2 = 0 ;
20802   Dali::Property::Value *arg3 = 0 ;
20803   Dali::Property::AccessMode arg4 ;
20804   Dali::Property::Index result;
20805
20806   arg1 = (Dali::Handle *)jarg1;
20807   if (!jarg2) {
20808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20809     return 0;
20810   }
20811   std::string arg2_str(jarg2);
20812   arg2 = &arg2_str;
20813   arg3 = (Dali::Property::Value *)jarg3;
20814   if (!arg3) {
20815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20816     return 0;
20817   }
20818   arg4 = (Dali::Property::AccessMode)jarg4;
20819   {
20820     try {
20821       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20822     } catch (std::out_of_range& e) {
20823       {
20824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20825       };
20826     } catch (std::exception& e) {
20827       {
20828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20829       };
20830     } catch (Dali::DaliException e) {
20831       {
20832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20833       };
20834     } catch (...) {
20835       {
20836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20837       };
20838     }
20839   }
20840
20841   jresult = result;
20842
20843   //argout typemap for const std::string&
20844
20845   return jresult;
20846 }
20847
20848
20849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20850   void * jresult ;
20851   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20852   Dali::Property::Index arg2 ;
20853   Dali::Property::Value result;
20854
20855   arg1 = (Dali::Handle *)jarg1;
20856   arg2 = (Dali::Property::Index)jarg2;
20857   {
20858     try {
20859       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20860     } catch (std::out_of_range& e) {
20861       {
20862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20863       };
20864     } catch (std::exception& e) {
20865       {
20866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20867       };
20868     } catch (Dali::DaliException e) {
20869       {
20870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20871       };
20872     } catch (...) {
20873       {
20874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20875       };
20876     }
20877   }
20878
20879   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20880   return jresult;
20881 }
20882
20883
20884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20885   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20886   Dali::Property::IndexContainer *arg2 = 0 ;
20887
20888   arg1 = (Dali::Handle *)jarg1;
20889   arg2 = (Dali::Property::IndexContainer *)jarg2;
20890   if (!arg2) {
20891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20892     return ;
20893   }
20894   {
20895     try {
20896       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20897     } catch (std::out_of_range& e) {
20898       {
20899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20900       };
20901     } catch (std::exception& e) {
20902       {
20903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20904       };
20905     } catch (Dali::DaliException e) {
20906       {
20907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20908       };
20909     } catch (...) {
20910       {
20911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20912       };
20913     }
20914   }
20915
20916 }
20917
20918
20919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20920   void * jresult ;
20921   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20922   Dali::Property::Index arg2 ;
20923   Dali::PropertyCondition *arg3 = 0 ;
20924   Dali::PropertyNotification result;
20925
20926   arg1 = (Dali::Handle *)jarg1;
20927   arg2 = (Dali::Property::Index)jarg2;
20928   arg3 = (Dali::PropertyCondition *)jarg3;
20929   if (!arg3) {
20930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20931     return 0;
20932   }
20933   {
20934     try {
20935       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20936     } catch (std::out_of_range& e) {
20937       {
20938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20939       };
20940     } catch (std::exception& e) {
20941       {
20942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20943       };
20944     } catch (Dali::DaliException e) {
20945       {
20946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20947       };
20948     } catch (...) {
20949       {
20950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20951       };
20952     }
20953   }
20954
20955   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20956   return jresult;
20957 }
20958
20959
20960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20961   void * jresult ;
20962   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20963   Dali::Property::Index arg2 ;
20964   int arg3 ;
20965   Dali::PropertyCondition *arg4 = 0 ;
20966   Dali::PropertyNotification result;
20967
20968   arg1 = (Dali::Handle *)jarg1;
20969   arg2 = (Dali::Property::Index)jarg2;
20970   arg3 = (int)jarg3;
20971   arg4 = (Dali::PropertyCondition *)jarg4;
20972   if (!arg4) {
20973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20974     return 0;
20975   }
20976   {
20977     try {
20978       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20979     } catch (std::out_of_range& e) {
20980       {
20981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20982       };
20983     } catch (std::exception& e) {
20984       {
20985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20986       };
20987     } catch (Dali::DaliException e) {
20988       {
20989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20990       };
20991     } catch (...) {
20992       {
20993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20994       };
20995     }
20996   }
20997
20998   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20999   return jresult;
21000 }
21001
21002
21003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21004   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21005   Dali::PropertyNotification arg2 ;
21006   Dali::PropertyNotification *argp2 ;
21007
21008   arg1 = (Dali::Handle *)jarg1;
21009   argp2 = (Dali::PropertyNotification *)jarg2;
21010   if (!argp2) {
21011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21012     return ;
21013   }
21014   arg2 = *argp2;
21015   {
21016     try {
21017       (arg1)->RemovePropertyNotification(arg2);
21018     } catch (std::out_of_range& e) {
21019       {
21020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21021       };
21022     } catch (std::exception& e) {
21023       {
21024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21025       };
21026     } catch (Dali::DaliException e) {
21027       {
21028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21029       };
21030     } catch (...) {
21031       {
21032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21033       };
21034     }
21035   }
21036
21037 }
21038
21039
21040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21041   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21042
21043   arg1 = (Dali::Handle *)jarg1;
21044   {
21045     try {
21046       (arg1)->RemovePropertyNotifications();
21047     } catch (std::out_of_range& e) {
21048       {
21049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21050       };
21051     } catch (std::exception& e) {
21052       {
21053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21054       };
21055     } catch (Dali::DaliException e) {
21056       {
21057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21058       };
21059     } catch (...) {
21060       {
21061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21062       };
21063     }
21064   }
21065
21066 }
21067
21068
21069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21070   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21071
21072   arg1 = (Dali::Handle *)jarg1;
21073   {
21074     try {
21075       (arg1)->RemoveConstraints();
21076     } catch (std::out_of_range& e) {
21077       {
21078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21079       };
21080     } catch (std::exception& e) {
21081       {
21082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21083       };
21084     } catch (Dali::DaliException e) {
21085       {
21086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21087       };
21088     } catch (...) {
21089       {
21090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21091       };
21092     }
21093   }
21094
21095 }
21096
21097
21098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21099   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21100   unsigned int arg2 ;
21101
21102   arg1 = (Dali::Handle *)jarg1;
21103   arg2 = (unsigned int)jarg2;
21104   {
21105     try {
21106       (arg1)->RemoveConstraints(arg2);
21107     } catch (std::out_of_range& e) {
21108       {
21109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21110       };
21111     } catch (std::exception& e) {
21112       {
21113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21114       };
21115     } catch (Dali::DaliException e) {
21116       {
21117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21118       };
21119     } catch (...) {
21120       {
21121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21122       };
21123     }
21124   }
21125
21126 }
21127
21128
21129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21130   int jresult ;
21131   Dali::Property::Index result;
21132
21133   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21134   jresult = result;
21135   return jresult;
21136 }
21137
21138
21139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21140   void * jresult ;
21141   Dali::Handle result;
21142
21143   {
21144     try {
21145       result = Dali::WeightObject::New();
21146     } catch (std::out_of_range& e) {
21147       {
21148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21149       };
21150     } catch (std::exception& e) {
21151       {
21152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21153       };
21154     } catch (Dali::DaliException e) {
21155       {
21156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21157       };
21158     } catch (...) {
21159       {
21160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21161       };
21162     }
21163   }
21164
21165   jresult = new Dali::Handle((const Dali::Handle &)result);
21166   return jresult;
21167 }
21168
21169
21170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21171   void * jresult ;
21172   Dali::TypeInfo *result = 0 ;
21173
21174   {
21175     try {
21176       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21177     } catch (std::out_of_range& e) {
21178       {
21179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21180       };
21181     } catch (std::exception& e) {
21182       {
21183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21184       };
21185     } catch (Dali::DaliException e) {
21186       {
21187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21188       };
21189     } catch (...) {
21190       {
21191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21192       };
21193     }
21194   }
21195
21196   jresult = (void *)result;
21197   return jresult;
21198 }
21199
21200
21201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21202   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21203
21204   arg1 = (Dali::TypeInfo *)jarg1;
21205   {
21206     try {
21207       delete arg1;
21208     } catch (std::out_of_range& e) {
21209       {
21210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21211       };
21212     } catch (std::exception& e) {
21213       {
21214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21215       };
21216     } catch (Dali::DaliException e) {
21217       {
21218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21219       };
21220     } catch (...) {
21221       {
21222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21223       };
21224     }
21225   }
21226
21227 }
21228
21229
21230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21231   void * jresult ;
21232   Dali::TypeInfo *arg1 = 0 ;
21233   Dali::TypeInfo *result = 0 ;
21234
21235   arg1 = (Dali::TypeInfo *)jarg1;
21236   if (!arg1) {
21237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21238     return 0;
21239   }
21240   {
21241     try {
21242       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21243     } catch (std::out_of_range& e) {
21244       {
21245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21246       };
21247     } catch (std::exception& e) {
21248       {
21249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21250       };
21251     } catch (Dali::DaliException e) {
21252       {
21253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21254       };
21255     } catch (...) {
21256       {
21257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21258       };
21259     }
21260   }
21261
21262   jresult = (void *)result;
21263   return jresult;
21264 }
21265
21266
21267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21268   void * jresult ;
21269   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21270   Dali::TypeInfo *arg2 = 0 ;
21271   Dali::TypeInfo *result = 0 ;
21272
21273   arg1 = (Dali::TypeInfo *)jarg1;
21274   arg2 = (Dali::TypeInfo *)jarg2;
21275   if (!arg2) {
21276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21277     return 0;
21278   }
21279   {
21280     try {
21281       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21282     } catch (std::out_of_range& e) {
21283       {
21284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21285       };
21286     } catch (std::exception& e) {
21287       {
21288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21289       };
21290     } catch (Dali::DaliException e) {
21291       {
21292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21293       };
21294     } catch (...) {
21295       {
21296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21297       };
21298     }
21299   }
21300
21301   jresult = (void *)result;
21302   return jresult;
21303 }
21304
21305
21306 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21307   char * jresult ;
21308   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21309   std::string *result = 0 ;
21310
21311   arg1 = (Dali::TypeInfo *)jarg1;
21312   {
21313     try {
21314       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21315     } catch (std::out_of_range& e) {
21316       {
21317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21318       };
21319     } catch (std::exception& e) {
21320       {
21321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21322       };
21323     } catch (Dali::DaliException e) {
21324       {
21325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21326       };
21327     } catch (...) {
21328       {
21329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21330       };
21331     }
21332   }
21333
21334   jresult = SWIG_csharp_string_callback(result->c_str());
21335   return jresult;
21336 }
21337
21338
21339 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21340   char * jresult ;
21341   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21342   std::string *result = 0 ;
21343
21344   arg1 = (Dali::TypeInfo *)jarg1;
21345   {
21346     try {
21347       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21348     } catch (std::out_of_range& e) {
21349       {
21350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21351       };
21352     } catch (std::exception& e) {
21353       {
21354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21355       };
21356     } catch (Dali::DaliException e) {
21357       {
21358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21359       };
21360     } catch (...) {
21361       {
21362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21363       };
21364     }
21365   }
21366
21367   jresult = SWIG_csharp_string_callback(result->c_str());
21368   return jresult;
21369 }
21370
21371
21372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21373   void * jresult ;
21374   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21375   Dali::BaseHandle result;
21376
21377   arg1 = (Dali::TypeInfo *)jarg1;
21378   {
21379     try {
21380       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21381     } catch (std::out_of_range& e) {
21382       {
21383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21384       };
21385     } catch (std::exception& e) {
21386       {
21387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21388       };
21389     } catch (Dali::DaliException e) {
21390       {
21391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21392       };
21393     } catch (...) {
21394       {
21395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21396       };
21397     }
21398   }
21399
21400   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21401   return jresult;
21402 }
21403
21404
21405 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21406   unsigned long jresult ;
21407   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21408   size_t result;
21409
21410   arg1 = (Dali::TypeInfo *)jarg1;
21411   {
21412     try {
21413       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21414     } catch (std::out_of_range& e) {
21415       {
21416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21417       };
21418     } catch (std::exception& e) {
21419       {
21420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21421       };
21422     } catch (Dali::DaliException e) {
21423       {
21424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21425       };
21426     } catch (...) {
21427       {
21428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21429       };
21430     }
21431   }
21432
21433   jresult = (unsigned long)result;
21434   return jresult;
21435 }
21436
21437
21438 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21439   char * jresult ;
21440   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21441   size_t arg2 ;
21442   std::string result;
21443
21444   arg1 = (Dali::TypeInfo *)jarg1;
21445   arg2 = (size_t)jarg2;
21446   {
21447     try {
21448       result = (arg1)->GetActionName(arg2);
21449     } catch (std::out_of_range& e) {
21450       {
21451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21452       };
21453     } catch (std::exception& e) {
21454       {
21455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21456       };
21457     } catch (Dali::DaliException e) {
21458       {
21459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21460       };
21461     } catch (...) {
21462       {
21463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21464       };
21465     }
21466   }
21467
21468   jresult = SWIG_csharp_string_callback((&result)->c_str());
21469   return jresult;
21470 }
21471
21472
21473 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21474   unsigned long jresult ;
21475   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21476   size_t result;
21477
21478   arg1 = (Dali::TypeInfo *)jarg1;
21479   {
21480     try {
21481       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21482     } catch (std::out_of_range& e) {
21483       {
21484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21485       };
21486     } catch (std::exception& e) {
21487       {
21488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21489       };
21490     } catch (Dali::DaliException e) {
21491       {
21492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21493       };
21494     } catch (...) {
21495       {
21496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21497       };
21498     }
21499   }
21500
21501   jresult = (unsigned long)result;
21502   return jresult;
21503 }
21504
21505
21506 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21507   char * jresult ;
21508   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21509   size_t arg2 ;
21510   std::string result;
21511
21512   arg1 = (Dali::TypeInfo *)jarg1;
21513   arg2 = (size_t)jarg2;
21514   {
21515     try {
21516       result = (arg1)->GetSignalName(arg2);
21517     } catch (std::out_of_range& e) {
21518       {
21519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21520       };
21521     } catch (std::exception& e) {
21522       {
21523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21524       };
21525     } catch (Dali::DaliException e) {
21526       {
21527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21528       };
21529     } catch (...) {
21530       {
21531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21532       };
21533     }
21534   }
21535
21536   jresult = SWIG_csharp_string_callback((&result)->c_str());
21537   return jresult;
21538 }
21539
21540
21541 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21542   unsigned long jresult ;
21543   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21544   size_t result;
21545
21546   arg1 = (Dali::TypeInfo *)jarg1;
21547   {
21548     try {
21549       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21550     } catch (std::out_of_range& e) {
21551       {
21552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21553       };
21554     } catch (std::exception& e) {
21555       {
21556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21557       };
21558     } catch (Dali::DaliException e) {
21559       {
21560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21561       };
21562     } catch (...) {
21563       {
21564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21565       };
21566     }
21567   }
21568
21569   jresult = (unsigned long)result;
21570   return jresult;
21571 }
21572
21573
21574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21575   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21576   Dali::Property::IndexContainer *arg2 = 0 ;
21577
21578   arg1 = (Dali::TypeInfo *)jarg1;
21579   arg2 = (Dali::Property::IndexContainer *)jarg2;
21580   if (!arg2) {
21581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21582     return ;
21583   }
21584   {
21585     try {
21586       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21587     } catch (std::out_of_range& e) {
21588       {
21589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21590       };
21591     } catch (std::exception& e) {
21592       {
21593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21594       };
21595     } catch (Dali::DaliException e) {
21596       {
21597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21598       };
21599     } catch (...) {
21600       {
21601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21602       };
21603     }
21604   }
21605
21606 }
21607
21608
21609 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21610   char * jresult ;
21611   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21612   Dali::Property::Index arg2 ;
21613   std::string *result = 0 ;
21614
21615   arg1 = (Dali::TypeInfo *)jarg1;
21616   arg2 = (Dali::Property::Index)jarg2;
21617   {
21618     try {
21619       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21620     } catch (std::out_of_range& e) {
21621       {
21622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21623       };
21624     } catch (std::exception& e) {
21625       {
21626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21627       };
21628     } catch (Dali::DaliException e) {
21629       {
21630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21631       };
21632     } catch (...) {
21633       {
21634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21635       };
21636     }
21637   }
21638
21639   jresult = SWIG_csharp_string_callback(result->c_str());
21640   return jresult;
21641 }
21642
21643
21644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21645   void * jresult ;
21646   Dali::TypeRegistry result;
21647
21648   {
21649     try {
21650       result = Dali::TypeRegistry::Get();
21651     } catch (std::out_of_range& e) {
21652       {
21653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21654       };
21655     } catch (std::exception& e) {
21656       {
21657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21658       };
21659     } catch (Dali::DaliException e) {
21660       {
21661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21662       };
21663     } catch (...) {
21664       {
21665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21666       };
21667     }
21668   }
21669
21670   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21671   return jresult;
21672 }
21673
21674
21675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21676   void * jresult ;
21677   Dali::TypeRegistry *result = 0 ;
21678
21679   {
21680     try {
21681       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21682     } catch (std::out_of_range& e) {
21683       {
21684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21685       };
21686     } catch (std::exception& e) {
21687       {
21688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21689       };
21690     } catch (Dali::DaliException e) {
21691       {
21692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21693       };
21694     } catch (...) {
21695       {
21696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21697       };
21698     }
21699   }
21700
21701   jresult = (void *)result;
21702   return jresult;
21703 }
21704
21705
21706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21707   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21708
21709   arg1 = (Dali::TypeRegistry *)jarg1;
21710   {
21711     try {
21712       delete arg1;
21713     } catch (std::out_of_range& e) {
21714       {
21715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21716       };
21717     } catch (std::exception& e) {
21718       {
21719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21720       };
21721     } catch (Dali::DaliException e) {
21722       {
21723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21724       };
21725     } catch (...) {
21726       {
21727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21728       };
21729     }
21730   }
21731
21732 }
21733
21734
21735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21736   void * jresult ;
21737   Dali::TypeRegistry *arg1 = 0 ;
21738   Dali::TypeRegistry *result = 0 ;
21739
21740   arg1 = (Dali::TypeRegistry *)jarg1;
21741   if (!arg1) {
21742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21743     return 0;
21744   }
21745   {
21746     try {
21747       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21748     } catch (std::out_of_range& e) {
21749       {
21750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21751       };
21752     } catch (std::exception& e) {
21753       {
21754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21755       };
21756     } catch (Dali::DaliException e) {
21757       {
21758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21759       };
21760     } catch (...) {
21761       {
21762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21763       };
21764     }
21765   }
21766
21767   jresult = (void *)result;
21768   return jresult;
21769 }
21770
21771
21772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21773   void * jresult ;
21774   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21775   Dali::TypeRegistry *arg2 = 0 ;
21776   Dali::TypeRegistry *result = 0 ;
21777
21778   arg1 = (Dali::TypeRegistry *)jarg1;
21779   arg2 = (Dali::TypeRegistry *)jarg2;
21780   if (!arg2) {
21781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21782     return 0;
21783   }
21784   {
21785     try {
21786       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21787     } catch (std::out_of_range& e) {
21788       {
21789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21790       };
21791     } catch (std::exception& e) {
21792       {
21793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21794       };
21795     } catch (Dali::DaliException e) {
21796       {
21797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21798       };
21799     } catch (...) {
21800       {
21801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21802       };
21803     }
21804   }
21805
21806   jresult = (void *)result;
21807   return jresult;
21808 }
21809
21810
21811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21812   void * jresult ;
21813   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21814   std::string *arg2 = 0 ;
21815   Dali::TypeInfo result;
21816
21817   arg1 = (Dali::TypeRegistry *)jarg1;
21818   if (!jarg2) {
21819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21820     return 0;
21821   }
21822   std::string arg2_str(jarg2);
21823   arg2 = &arg2_str;
21824   {
21825     try {
21826       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21827     } catch (std::out_of_range& e) {
21828       {
21829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21830       };
21831     } catch (std::exception& e) {
21832       {
21833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21834       };
21835     } catch (Dali::DaliException e) {
21836       {
21837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21838       };
21839     } catch (...) {
21840       {
21841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21842       };
21843     }
21844   }
21845
21846   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21847
21848   //argout typemap for const std::string&
21849
21850   return jresult;
21851 }
21852
21853
21854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21855   void * jresult ;
21856   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21857   std::type_info *arg2 = 0 ;
21858   Dali::TypeInfo result;
21859
21860   arg1 = (Dali::TypeRegistry *)jarg1;
21861   arg2 = (std::type_info *)jarg2;
21862   if (!arg2) {
21863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21864     return 0;
21865   }
21866   {
21867     try {
21868       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21869     } catch (std::out_of_range& e) {
21870       {
21871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21872       };
21873     } catch (std::exception& e) {
21874       {
21875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21876       };
21877     } catch (Dali::DaliException e) {
21878       {
21879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21880       };
21881     } catch (...) {
21882       {
21883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21884       };
21885     }
21886   }
21887
21888   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21889   return jresult;
21890 }
21891
21892
21893 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21894   unsigned long jresult ;
21895   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21896   size_t result;
21897
21898   arg1 = (Dali::TypeRegistry *)jarg1;
21899   {
21900     try {
21901       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21902     } catch (std::out_of_range& e) {
21903       {
21904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21905       };
21906     } catch (std::exception& e) {
21907       {
21908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21909       };
21910     } catch (Dali::DaliException e) {
21911       {
21912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21913       };
21914     } catch (...) {
21915       {
21916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21917       };
21918     }
21919   }
21920
21921   jresult = (unsigned long)result;
21922   return jresult;
21923 }
21924
21925
21926 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21927   char * jresult ;
21928   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21929   size_t arg2 ;
21930   std::string result;
21931
21932   arg1 = (Dali::TypeRegistry *)jarg1;
21933   arg2 = (size_t)jarg2;
21934   {
21935     try {
21936       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21937     } catch (std::out_of_range& e) {
21938       {
21939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21940       };
21941     } catch (std::exception& e) {
21942       {
21943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21944       };
21945     } catch (Dali::DaliException e) {
21946       {
21947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21948       };
21949     } catch (...) {
21950       {
21951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21952       };
21953     }
21954   }
21955
21956   jresult = SWIG_csharp_string_callback((&result)->c_str());
21957   return jresult;
21958 }
21959
21960
21961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
21962   void * jresult ;
21963   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
21964   Dali::TypeRegistry *result = 0 ;
21965
21966   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
21967   {
21968     try {
21969       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
21970     } catch (std::out_of_range& e) {
21971       {
21972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21973       };
21974     } catch (std::exception& e) {
21975       {
21976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21977       };
21978     } catch (Dali::DaliException e) {
21979       {
21980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21981       };
21982     } catch (...) {
21983       {
21984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21985       };
21986     }
21987   }
21988
21989   jresult = (void *)result;
21990   return jresult;
21991 }
21992
21993
21994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21995   void * jresult ;
21996   std::type_info *arg1 = 0 ;
21997   std::type_info *arg2 = 0 ;
21998   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21999   Dali::TypeRegistration *result = 0 ;
22000
22001   arg1 = (std::type_info *)jarg1;
22002   if (!arg1) {
22003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22004     return 0;
22005   }
22006   arg2 = (std::type_info *)jarg2;
22007   if (!arg2) {
22008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22009     return 0;
22010   }
22011   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22012   {
22013     try {
22014       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22015     } catch (std::out_of_range& e) {
22016       {
22017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22018       };
22019     } catch (std::exception& e) {
22020       {
22021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22022       };
22023     } catch (Dali::DaliException e) {
22024       {
22025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22026       };
22027     } catch (...) {
22028       {
22029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22030       };
22031     }
22032   }
22033
22034   jresult = (void *)result;
22035   return jresult;
22036 }
22037
22038
22039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22040   void * jresult ;
22041   std::type_info *arg1 = 0 ;
22042   std::type_info *arg2 = 0 ;
22043   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22044   bool arg4 ;
22045   Dali::TypeRegistration *result = 0 ;
22046
22047   arg1 = (std::type_info *)jarg1;
22048   if (!arg1) {
22049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22050     return 0;
22051   }
22052   arg2 = (std::type_info *)jarg2;
22053   if (!arg2) {
22054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22055     return 0;
22056   }
22057   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22058   arg4 = jarg4 ? true : false;
22059   {
22060     try {
22061       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22062     } catch (std::out_of_range& e) {
22063       {
22064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22065       };
22066     } catch (std::exception& e) {
22067       {
22068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22069       };
22070     } catch (Dali::DaliException e) {
22071       {
22072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22073       };
22074     } catch (...) {
22075       {
22076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22077       };
22078     }
22079   }
22080
22081   jresult = (void *)result;
22082   return jresult;
22083 }
22084
22085
22086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22087   void * jresult ;
22088   std::string *arg1 = 0 ;
22089   std::type_info *arg2 = 0 ;
22090   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22091   Dali::TypeRegistration *result = 0 ;
22092
22093   if (!jarg1) {
22094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22095     return 0;
22096   }
22097   std::string arg1_str(jarg1);
22098   arg1 = &arg1_str;
22099   arg2 = (std::type_info *)jarg2;
22100   if (!arg2) {
22101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22102     return 0;
22103   }
22104   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22105   {
22106     try {
22107       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22108     } catch (std::out_of_range& e) {
22109       {
22110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22111       };
22112     } catch (std::exception& e) {
22113       {
22114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22115       };
22116     } catch (Dali::DaliException e) {
22117       {
22118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22119       };
22120     } catch (...) {
22121       {
22122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22123       };
22124     }
22125   }
22126
22127   jresult = (void *)result;
22128
22129   //argout typemap for const std::string&
22130
22131   return jresult;
22132 }
22133
22134
22135 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22136   char * jresult ;
22137   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22138   std::string result;
22139
22140   arg1 = (Dali::TypeRegistration *)jarg1;
22141   {
22142     try {
22143       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22144     } catch (std::out_of_range& e) {
22145       {
22146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22147       };
22148     } catch (std::exception& e) {
22149       {
22150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22151       };
22152     } catch (Dali::DaliException e) {
22153       {
22154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22155       };
22156     } catch (...) {
22157       {
22158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22159       };
22160     }
22161   }
22162
22163   jresult = SWIG_csharp_string_callback((&result)->c_str());
22164   return jresult;
22165 }
22166
22167
22168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22169   std::string *arg1 = 0 ;
22170   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22171
22172   if (!jarg1) {
22173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22174     return ;
22175   }
22176   std::string arg1_str(jarg1);
22177   arg1 = &arg1_str;
22178   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22179   {
22180     try {
22181       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22182     } catch (std::out_of_range& e) {
22183       {
22184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22185       };
22186     } catch (std::exception& e) {
22187       {
22188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22189       };
22190     } catch (Dali::DaliException e) {
22191       {
22192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22193       };
22194     } catch (...) {
22195       {
22196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22197       };
22198     }
22199   }
22200
22201
22202   //argout typemap for const std::string&
22203
22204 }
22205
22206
22207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22208   std::string *arg1 = 0 ;
22209   std::string *arg2 = 0 ;
22210   int arg3 ;
22211   Dali::Property::Type arg4 ;
22212   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22213   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22214
22215   if (!jarg1) {
22216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22217     return ;
22218   }
22219   std::string arg1_str(jarg1);
22220   arg1 = &arg1_str;
22221   if (!jarg2) {
22222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22223     return ;
22224   }
22225   std::string arg2_str(jarg2);
22226   arg2 = &arg2_str;
22227   arg3 = (int)jarg3;
22228   arg4 = (Dali::Property::Type)jarg4;
22229   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22230   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22231   {
22232     try {
22233       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22234     } catch (std::out_of_range& e) {
22235       {
22236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22237       };
22238     } catch (std::exception& e) {
22239       {
22240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22241       };
22242     } catch (Dali::DaliException e) {
22243       {
22244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22245       };
22246     } catch (...) {
22247       {
22248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22249       };
22250     }
22251   }
22252
22253
22254   //argout typemap for const std::string&
22255
22256
22257   //argout typemap for const std::string&
22258
22259 }
22260
22261
22262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22263   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22264
22265   arg1 = (Dali::TypeRegistration *)jarg1;
22266   {
22267     try {
22268       delete arg1;
22269     } catch (std::out_of_range& e) {
22270       {
22271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22272       };
22273     } catch (std::exception& e) {
22274       {
22275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22276       };
22277     } catch (Dali::DaliException e) {
22278       {
22279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22280       };
22281     } catch (...) {
22282       {
22283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22284       };
22285     }
22286   }
22287
22288 }
22289
22290
22291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22292   void * jresult ;
22293   Dali::TypeRegistration *arg1 = 0 ;
22294   std::string *arg2 = 0 ;
22295   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22296   Dali::SignalConnectorType *result = 0 ;
22297
22298   arg1 = (Dali::TypeRegistration *)jarg1;
22299   if (!arg1) {
22300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22301     return 0;
22302   }
22303   if (!jarg2) {
22304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22305     return 0;
22306   }
22307   std::string arg2_str(jarg2);
22308   arg2 = &arg2_str;
22309   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22310   {
22311     try {
22312       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22313     } catch (std::out_of_range& e) {
22314       {
22315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22316       };
22317     } catch (std::exception& e) {
22318       {
22319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22320       };
22321     } catch (Dali::DaliException e) {
22322       {
22323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22324       };
22325     } catch (...) {
22326       {
22327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22328       };
22329     }
22330   }
22331
22332   jresult = (void *)result;
22333
22334   //argout typemap for const std::string&
22335
22336   return jresult;
22337 }
22338
22339
22340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22341   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22342
22343   arg1 = (Dali::SignalConnectorType *)jarg1;
22344   {
22345     try {
22346       delete arg1;
22347     } catch (std::out_of_range& e) {
22348       {
22349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22350       };
22351     } catch (std::exception& e) {
22352       {
22353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22354       };
22355     } catch (Dali::DaliException e) {
22356       {
22357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22358       };
22359     } catch (...) {
22360       {
22361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22362       };
22363     }
22364   }
22365
22366 }
22367
22368
22369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22370   void * jresult ;
22371   Dali::TypeRegistration *arg1 = 0 ;
22372   std::string *arg2 = 0 ;
22373   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22374   Dali::TypeAction *result = 0 ;
22375
22376   arg1 = (Dali::TypeRegistration *)jarg1;
22377   if (!arg1) {
22378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22379     return 0;
22380   }
22381   if (!jarg2) {
22382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22383     return 0;
22384   }
22385   std::string arg2_str(jarg2);
22386   arg2 = &arg2_str;
22387   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22388   {
22389     try {
22390       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22391     } catch (std::out_of_range& e) {
22392       {
22393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22394       };
22395     } catch (std::exception& e) {
22396       {
22397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22398       };
22399     } catch (Dali::DaliException e) {
22400       {
22401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22402       };
22403     } catch (...) {
22404       {
22405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22406       };
22407     }
22408   }
22409
22410   jresult = (void *)result;
22411
22412   //argout typemap for const std::string&
22413
22414   return jresult;
22415 }
22416
22417
22418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22419   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22420
22421   arg1 = (Dali::TypeAction *)jarg1;
22422   {
22423     try {
22424       delete arg1;
22425     } catch (std::out_of_range& e) {
22426       {
22427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22428       };
22429     } catch (std::exception& e) {
22430       {
22431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22432       };
22433     } catch (Dali::DaliException e) {
22434       {
22435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22436       };
22437     } catch (...) {
22438       {
22439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22440       };
22441     }
22442   }
22443
22444 }
22445
22446
22447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22448   void * jresult ;
22449   Dali::TypeRegistration *arg1 = 0 ;
22450   std::string *arg2 = 0 ;
22451   Dali::Property::Index arg3 ;
22452   Dali::Property::Type arg4 ;
22453   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22454   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22455   Dali::PropertyRegistration *result = 0 ;
22456
22457   arg1 = (Dali::TypeRegistration *)jarg1;
22458   if (!arg1) {
22459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22460     return 0;
22461   }
22462   if (!jarg2) {
22463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22464     return 0;
22465   }
22466   std::string arg2_str(jarg2);
22467   arg2 = &arg2_str;
22468   arg3 = (Dali::Property::Index)jarg3;
22469   arg4 = (Dali::Property::Type)jarg4;
22470   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22471   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22472   {
22473     try {
22474       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22475     } catch (std::out_of_range& e) {
22476       {
22477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22478       };
22479     } catch (std::exception& e) {
22480       {
22481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22482       };
22483     } catch (Dali::DaliException e) {
22484       {
22485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22486       };
22487     } catch (...) {
22488       {
22489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22490       };
22491     }
22492   }
22493
22494   jresult = (void *)result;
22495
22496   //argout typemap for const std::string&
22497
22498   return jresult;
22499 }
22500
22501
22502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22503   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22504
22505   arg1 = (Dali::PropertyRegistration *)jarg1;
22506   {
22507     try {
22508       delete arg1;
22509     } catch (std::out_of_range& e) {
22510       {
22511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22512       };
22513     } catch (std::exception& e) {
22514       {
22515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22516       };
22517     } catch (Dali::DaliException e) {
22518       {
22519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22520       };
22521     } catch (...) {
22522       {
22523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22524       };
22525     }
22526   }
22527
22528 }
22529
22530
22531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22532   void * jresult ;
22533   Dali::TypeRegistration *arg1 = 0 ;
22534   std::string *arg2 = 0 ;
22535   Dali::Property::Index arg3 ;
22536   Dali::Property::Type arg4 ;
22537   Dali::AnimatablePropertyRegistration *result = 0 ;
22538
22539   arg1 = (Dali::TypeRegistration *)jarg1;
22540   if (!arg1) {
22541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22542     return 0;
22543   }
22544   if (!jarg2) {
22545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22546     return 0;
22547   }
22548   std::string arg2_str(jarg2);
22549   arg2 = &arg2_str;
22550   arg3 = (Dali::Property::Index)jarg3;
22551   arg4 = (Dali::Property::Type)jarg4;
22552   {
22553     try {
22554       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22555     } catch (std::out_of_range& e) {
22556       {
22557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22558       };
22559     } catch (std::exception& e) {
22560       {
22561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22562       };
22563     } catch (Dali::DaliException e) {
22564       {
22565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22566       };
22567     } catch (...) {
22568       {
22569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22570       };
22571     }
22572   }
22573
22574   jresult = (void *)result;
22575
22576   //argout typemap for const std::string&
22577
22578   return jresult;
22579 }
22580
22581
22582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22583   void * jresult ;
22584   Dali::TypeRegistration *arg1 = 0 ;
22585   std::string *arg2 = 0 ;
22586   Dali::Property::Index arg3 ;
22587   Dali::Property::Value *arg4 = 0 ;
22588   Dali::AnimatablePropertyRegistration *result = 0 ;
22589
22590   arg1 = (Dali::TypeRegistration *)jarg1;
22591   if (!arg1) {
22592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22593     return 0;
22594   }
22595   if (!jarg2) {
22596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22597     return 0;
22598   }
22599   std::string arg2_str(jarg2);
22600   arg2 = &arg2_str;
22601   arg3 = (Dali::Property::Index)jarg3;
22602   arg4 = (Dali::Property::Value *)jarg4;
22603   if (!arg4) {
22604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22605     return 0;
22606   }
22607   {
22608     try {
22609       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22610     } catch (std::out_of_range& e) {
22611       {
22612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22613       };
22614     } catch (std::exception& e) {
22615       {
22616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22617       };
22618     } catch (Dali::DaliException e) {
22619       {
22620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22621       };
22622     } catch (...) {
22623       {
22624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22625       };
22626     }
22627   }
22628
22629   jresult = (void *)result;
22630
22631   //argout typemap for const std::string&
22632
22633   return jresult;
22634 }
22635
22636
22637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22638   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22639
22640   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22641   {
22642     try {
22643       delete arg1;
22644     } catch (std::out_of_range& e) {
22645       {
22646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22647       };
22648     } catch (std::exception& e) {
22649       {
22650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22651       };
22652     } catch (Dali::DaliException e) {
22653       {
22654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22655       };
22656     } catch (...) {
22657       {
22658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22659       };
22660     }
22661   }
22662
22663 }
22664
22665
22666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22667   void * jresult ;
22668   Dali::TypeRegistration *arg1 = 0 ;
22669   std::string *arg2 = 0 ;
22670   Dali::Property::Index arg3 ;
22671   Dali::Property::Index arg4 ;
22672   unsigned int arg5 ;
22673   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22674
22675   arg1 = (Dali::TypeRegistration *)jarg1;
22676   if (!arg1) {
22677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22678     return 0;
22679   }
22680   if (!jarg2) {
22681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22682     return 0;
22683   }
22684   std::string arg2_str(jarg2);
22685   arg2 = &arg2_str;
22686   arg3 = (Dali::Property::Index)jarg3;
22687   arg4 = (Dali::Property::Index)jarg4;
22688   arg5 = (unsigned int)jarg5;
22689   {
22690     try {
22691       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22692     } catch (std::out_of_range& e) {
22693       {
22694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22695       };
22696     } catch (std::exception& e) {
22697       {
22698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22699       };
22700     } catch (Dali::DaliException e) {
22701       {
22702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22703       };
22704     } catch (...) {
22705       {
22706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22707       };
22708     }
22709   }
22710
22711   jresult = (void *)result;
22712
22713   //argout typemap for const std::string&
22714
22715   return jresult;
22716 }
22717
22718
22719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22720   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22721
22722   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22723   {
22724     try {
22725       delete arg1;
22726     } catch (std::out_of_range& e) {
22727       {
22728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22729       };
22730     } catch (std::exception& e) {
22731       {
22732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22733       };
22734     } catch (Dali::DaliException e) {
22735       {
22736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22737       };
22738     } catch (...) {
22739       {
22740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22741       };
22742     }
22743   }
22744
22745 }
22746
22747
22748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22749   void * jresult ;
22750   Dali::TypeRegistration *arg1 = 0 ;
22751   std::string *arg2 = 0 ;
22752   Dali::Property::Index arg3 ;
22753   Dali::Property::Type arg4 ;
22754   Dali::ChildPropertyRegistration *result = 0 ;
22755
22756   arg1 = (Dali::TypeRegistration *)jarg1;
22757   if (!arg1) {
22758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22759     return 0;
22760   }
22761   if (!jarg2) {
22762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22763     return 0;
22764   }
22765   std::string arg2_str(jarg2);
22766   arg2 = &arg2_str;
22767   arg3 = (Dali::Property::Index)jarg3;
22768   arg4 = (Dali::Property::Type)jarg4;
22769   {
22770     try {
22771       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22772     } catch (std::out_of_range& e) {
22773       {
22774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22775       };
22776     } catch (std::exception& e) {
22777       {
22778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22779       };
22780     } catch (Dali::DaliException e) {
22781       {
22782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22783       };
22784     } catch (...) {
22785       {
22786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22787       };
22788     }
22789   }
22790
22791   jresult = (void *)result;
22792
22793   //argout typemap for const std::string&
22794
22795   return jresult;
22796 }
22797
22798
22799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22800   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22801
22802   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22803   {
22804     try {
22805       delete arg1;
22806     } catch (std::out_of_range& e) {
22807       {
22808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22809       };
22810     } catch (std::exception& e) {
22811       {
22812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22813       };
22814     } catch (Dali::DaliException e) {
22815       {
22816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22817       };
22818     } catch (...) {
22819       {
22820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22821       };
22822     }
22823   }
22824
22825 }
22826
22827
22828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22829   unsigned int jresult ;
22830   std::string *arg1 = 0 ;
22831   std::type_info *arg2 = 0 ;
22832   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22833   bool result;
22834
22835   if (!jarg1) {
22836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22837     return 0;
22838   }
22839   std::string arg1_str(jarg1);
22840   arg1 = &arg1_str;
22841   arg2 = (std::type_info *)jarg2;
22842   if (!arg2) {
22843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22844     return 0;
22845   }
22846   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22847   {
22848     try {
22849       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22850     } catch (std::out_of_range& e) {
22851       {
22852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22853       };
22854     } catch (std::exception& e) {
22855       {
22856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22857       };
22858     } catch (Dali::DaliException e) {
22859       {
22860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22861       };
22862     } catch (...) {
22863       {
22864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22865       };
22866     }
22867   }
22868
22869   jresult = result;
22870
22871   //argout typemap for const std::string&
22872
22873   return jresult;
22874 }
22875
22876
22877 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22878   unsigned int jresult ;
22879   std::string *arg1 = 0 ;
22880   std::string *arg2 = 0 ;
22881   Dali::Property::Index arg3 ;
22882   Dali::Property::Type arg4 ;
22883   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22884   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22885   bool result;
22886
22887   if (!jarg1) {
22888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22889     return 0;
22890   }
22891   std::string arg1_str(jarg1);
22892   arg1 = &arg1_str;
22893   if (!jarg2) {
22894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22895     return 0;
22896   }
22897   std::string arg2_str(jarg2);
22898   arg2 = &arg2_str;
22899   arg3 = (Dali::Property::Index)jarg3;
22900   arg4 = (Dali::Property::Type)jarg4;
22901   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22902   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22903   {
22904     try {
22905       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22906     } catch (std::out_of_range& e) {
22907       {
22908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22909       };
22910     } catch (std::exception& e) {
22911       {
22912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22913       };
22914     } catch (Dali::DaliException e) {
22915       {
22916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22917       };
22918     } catch (...) {
22919       {
22920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22921       };
22922     }
22923   }
22924
22925   jresult = result;
22926
22927   //argout typemap for const std::string&
22928
22929
22930   //argout typemap for const std::string&
22931
22932   return jresult;
22933 }
22934
22935
22936 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22937   float jresult ;
22938   float result;
22939
22940   result = (float)(float)Dali::ParentOrigin::TOP;
22941   jresult = result;
22942   return jresult;
22943 }
22944
22945
22946 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22947   float jresult ;
22948   float result;
22949
22950   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22951   jresult = result;
22952   return jresult;
22953 }
22954
22955
22956 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22957   float jresult ;
22958   float result;
22959
22960   result = (float)(float)Dali::ParentOrigin::LEFT;
22961   jresult = result;
22962   return jresult;
22963 }
22964
22965
22966 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22967   float jresult ;
22968   float result;
22969
22970   result = (float)(float)Dali::ParentOrigin::RIGHT;
22971   jresult = result;
22972   return jresult;
22973 }
22974
22975
22976 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22977   float jresult ;
22978   float result;
22979
22980   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22981   jresult = result;
22982   return jresult;
22983 }
22984
22985
22986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22987   void * jresult ;
22988   Dali::Vector3 *result = 0 ;
22989
22990   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22991   jresult = (void *)result;
22992   return jresult;
22993 }
22994
22995
22996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22997   void * jresult ;
22998   Dali::Vector3 *result = 0 ;
22999
23000   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
23001   jresult = (void *)result;
23002   return jresult;
23003 }
23004
23005
23006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
23007   void * jresult ;
23008   Dali::Vector3 *result = 0 ;
23009
23010   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23011   jresult = (void *)result;
23012   return jresult;
23013 }
23014
23015
23016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23017   void * jresult ;
23018   Dali::Vector3 *result = 0 ;
23019
23020   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23021   jresult = (void *)result;
23022   return jresult;
23023 }
23024
23025
23026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23027   void * jresult ;
23028   Dali::Vector3 *result = 0 ;
23029
23030   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23031   jresult = (void *)result;
23032   return jresult;
23033 }
23034
23035
23036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23037   void * jresult ;
23038   Dali::Vector3 *result = 0 ;
23039
23040   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23041   jresult = (void *)result;
23042   return jresult;
23043 }
23044
23045
23046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23047   void * jresult ;
23048   Dali::Vector3 *result = 0 ;
23049
23050   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23051   jresult = (void *)result;
23052   return jresult;
23053 }
23054
23055
23056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23057   void * jresult ;
23058   Dali::Vector3 *result = 0 ;
23059
23060   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23061   jresult = (void *)result;
23062   return jresult;
23063 }
23064
23065
23066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23067   void * jresult ;
23068   Dali::Vector3 *result = 0 ;
23069
23070   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23071   jresult = (void *)result;
23072   return jresult;
23073 }
23074
23075
23076 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23077   float jresult ;
23078   float result;
23079
23080   result = (float)(float)Dali::AnchorPoint::TOP;
23081   jresult = result;
23082   return jresult;
23083 }
23084
23085
23086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23087   float jresult ;
23088   float result;
23089
23090   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23091   jresult = result;
23092   return jresult;
23093 }
23094
23095
23096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23097   float jresult ;
23098   float result;
23099
23100   result = (float)(float)Dali::AnchorPoint::LEFT;
23101   jresult = result;
23102   return jresult;
23103 }
23104
23105
23106 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23107   float jresult ;
23108   float result;
23109
23110   result = (float)(float)Dali::AnchorPoint::RIGHT;
23111   jresult = result;
23112   return jresult;
23113 }
23114
23115
23116 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23117   float jresult ;
23118   float result;
23119
23120   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23121   jresult = result;
23122   return jresult;
23123 }
23124
23125
23126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23127   void * jresult ;
23128   Dali::Vector3 *result = 0 ;
23129
23130   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23131   jresult = (void *)result;
23132   return jresult;
23133 }
23134
23135
23136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23137   void * jresult ;
23138   Dali::Vector3 *result = 0 ;
23139
23140   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23141   jresult = (void *)result;
23142   return jresult;
23143 }
23144
23145
23146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23147   void * jresult ;
23148   Dali::Vector3 *result = 0 ;
23149
23150   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23151   jresult = (void *)result;
23152   return jresult;
23153 }
23154
23155
23156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23157   void * jresult ;
23158   Dali::Vector3 *result = 0 ;
23159
23160   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23161   jresult = (void *)result;
23162   return jresult;
23163 }
23164
23165
23166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23167   void * jresult ;
23168   Dali::Vector3 *result = 0 ;
23169
23170   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23171   jresult = (void *)result;
23172   return jresult;
23173 }
23174
23175
23176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23177   void * jresult ;
23178   Dali::Vector3 *result = 0 ;
23179
23180   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23181   jresult = (void *)result;
23182   return jresult;
23183 }
23184
23185
23186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23187   void * jresult ;
23188   Dali::Vector3 *result = 0 ;
23189
23190   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23191   jresult = (void *)result;
23192   return jresult;
23193 }
23194
23195
23196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23197   void * jresult ;
23198   Dali::Vector3 *result = 0 ;
23199
23200   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23201   jresult = (void *)result;
23202   return jresult;
23203 }
23204
23205
23206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23207   void * jresult ;
23208   Dali::Vector3 *result = 0 ;
23209
23210   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23211   jresult = (void *)result;
23212   return jresult;
23213 }
23214
23215
23216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23217   void * jresult ;
23218   Dali::Vector4 *result = 0 ;
23219
23220   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23221   jresult = (void *)result;
23222   return jresult;
23223 }
23224
23225
23226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23227   void * jresult ;
23228   Dali::Vector4 *result = 0 ;
23229
23230   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23231   jresult = (void *)result;
23232   return jresult;
23233 }
23234
23235
23236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23237   void * jresult ;
23238   Dali::Vector4 *result = 0 ;
23239
23240   result = (Dali::Vector4 *)&Dali::Color::RED;
23241   jresult = (void *)result;
23242   return jresult;
23243 }
23244
23245
23246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23247   void * jresult ;
23248   Dali::Vector4 *result = 0 ;
23249
23250   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23251   jresult = (void *)result;
23252   return jresult;
23253 }
23254
23255
23256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23257   void * jresult ;
23258   Dali::Vector4 *result = 0 ;
23259
23260   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23261   jresult = (void *)result;
23262   return jresult;
23263 }
23264
23265
23266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23267   void * jresult ;
23268   Dali::Vector4 *result = 0 ;
23269
23270   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23271   jresult = (void *)result;
23272   return jresult;
23273 }
23274
23275
23276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23277   void * jresult ;
23278   Dali::Vector4 *result = 0 ;
23279
23280   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23281   jresult = (void *)result;
23282   return jresult;
23283 }
23284
23285
23286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23287   void * jresult ;
23288   Dali::Vector4 *result = 0 ;
23289
23290   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23291   jresult = (void *)result;
23292   return jresult;
23293 }
23294
23295
23296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23297   void * jresult ;
23298   Dali::Vector4 *result = 0 ;
23299
23300   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23301   jresult = (void *)result;
23302   return jresult;
23303 }
23304
23305
23306 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23307   float jresult ;
23308   float result;
23309
23310   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23311   jresult = result;
23312   return jresult;
23313 }
23314
23315
23316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23317   float jresult ;
23318   float result;
23319
23320   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23321   jresult = result;
23322   return jresult;
23323 }
23324
23325
23326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23327   float jresult ;
23328   float result;
23329
23330   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23331   jresult = result;
23332   return jresult;
23333 }
23334
23335
23336 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23337   float jresult ;
23338   float result;
23339
23340   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23341   jresult = result;
23342   return jresult;
23343 }
23344
23345
23346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23347   float jresult ;
23348   float result;
23349
23350   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23351   jresult = result;
23352   return jresult;
23353 }
23354
23355
23356 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23357   float jresult ;
23358   float result;
23359
23360   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23361   jresult = result;
23362   return jresult;
23363 }
23364
23365
23366 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23367   float jresult ;
23368   float result;
23369
23370   result = (float)(float)Dali::Math::PI;
23371   jresult = result;
23372   return jresult;
23373 }
23374
23375
23376 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23377   float jresult ;
23378   float result;
23379
23380   result = (float)(float)Dali::Math::PI_2;
23381   jresult = result;
23382   return jresult;
23383 }
23384
23385
23386 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23387   float jresult ;
23388   float result;
23389
23390   result = (float)(float)Dali::Math::PI_4;
23391   jresult = result;
23392   return jresult;
23393 }
23394
23395
23396 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23397   float jresult ;
23398   float result;
23399
23400   result = (float)(float)Dali::Math::PI_OVER_180;
23401   jresult = result;
23402   return jresult;
23403 }
23404
23405
23406 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23407   float jresult ;
23408   float result;
23409
23410   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23411   jresult = result;
23412   return jresult;
23413 }
23414
23415
23416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23417   int jresult ;
23418   Dali::ResizePolicy::Type result;
23419
23420   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23421   jresult = (int)result;
23422   return jresult;
23423 }
23424
23425
23426 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23427   unsigned long jresult ;
23428   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23429   Dali::VectorBase::SizeType result;
23430
23431   arg1 = (Dali::VectorBase *)jarg1;
23432   {
23433     try {
23434       result = ((Dali::VectorBase const *)arg1)->Count();
23435     } catch (std::out_of_range& e) {
23436       {
23437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23438       };
23439     } catch (std::exception& e) {
23440       {
23441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23442       };
23443     } catch (Dali::DaliException e) {
23444       {
23445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23446       };
23447     } catch (...) {
23448       {
23449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23450       };
23451     }
23452   }
23453
23454   jresult = (unsigned long)result;
23455   return jresult;
23456 }
23457
23458
23459 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23460   unsigned long jresult ;
23461   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23462   Dali::VectorBase::SizeType result;
23463
23464   arg1 = (Dali::VectorBase *)jarg1;
23465   {
23466     try {
23467       result = ((Dali::VectorBase const *)arg1)->Size();
23468     } catch (std::out_of_range& e) {
23469       {
23470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23471       };
23472     } catch (std::exception& e) {
23473       {
23474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23475       };
23476     } catch (Dali::DaliException e) {
23477       {
23478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23479       };
23480     } catch (...) {
23481       {
23482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23483       };
23484     }
23485   }
23486
23487   jresult = (unsigned long)result;
23488   return jresult;
23489 }
23490
23491
23492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23493   unsigned int jresult ;
23494   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23495   bool result;
23496
23497   arg1 = (Dali::VectorBase *)jarg1;
23498   {
23499     try {
23500       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23501     } catch (std::out_of_range& e) {
23502       {
23503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23504       };
23505     } catch (std::exception& e) {
23506       {
23507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23508       };
23509     } catch (Dali::DaliException e) {
23510       {
23511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23512       };
23513     } catch (...) {
23514       {
23515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23516       };
23517     }
23518   }
23519
23520   jresult = result;
23521   return jresult;
23522 }
23523
23524
23525 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23526   unsigned long jresult ;
23527   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23528   Dali::VectorBase::SizeType result;
23529
23530   arg1 = (Dali::VectorBase *)jarg1;
23531   {
23532     try {
23533       result = ((Dali::VectorBase const *)arg1)->Capacity();
23534     } catch (std::out_of_range& e) {
23535       {
23536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23537       };
23538     } catch (std::exception& e) {
23539       {
23540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23541       };
23542     } catch (Dali::DaliException e) {
23543       {
23544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23545       };
23546     } catch (...) {
23547       {
23548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23549       };
23550     }
23551   }
23552
23553   jresult = (unsigned long)result;
23554   return jresult;
23555 }
23556
23557
23558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23559   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23560
23561   arg1 = (Dali::VectorBase *)jarg1;
23562   {
23563     try {
23564       (arg1)->Release();
23565     } catch (std::out_of_range& e) {
23566       {
23567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23568       };
23569     } catch (std::exception& e) {
23570       {
23571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23572       };
23573     } catch (Dali::DaliException e) {
23574       {
23575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23576       };
23577     } catch (...) {
23578       {
23579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23580       };
23581     }
23582   }
23583
23584 }
23585
23586
23587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23588   void * jresult ;
23589   Dali::Image *result = 0 ;
23590
23591   {
23592     try {
23593       result = (Dali::Image *)new Dali::Image();
23594     } catch (std::out_of_range& e) {
23595       {
23596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23597       };
23598     } catch (std::exception& e) {
23599       {
23600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23601       };
23602     } catch (Dali::DaliException e) {
23603       {
23604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23605       };
23606     } catch (...) {
23607       {
23608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23609       };
23610     }
23611   }
23612
23613   jresult = (void *)result;
23614   return jresult;
23615 }
23616
23617
23618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23619   Dali::Image *arg1 = (Dali::Image *) 0 ;
23620
23621   arg1 = (Dali::Image *)jarg1;
23622   {
23623     try {
23624       delete arg1;
23625     } catch (std::out_of_range& e) {
23626       {
23627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23628       };
23629     } catch (std::exception& e) {
23630       {
23631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23632       };
23633     } catch (Dali::DaliException e) {
23634       {
23635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23636       };
23637     } catch (...) {
23638       {
23639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23640       };
23641     }
23642   }
23643
23644 }
23645
23646
23647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23648   void * jresult ;
23649   Dali::Image *arg1 = 0 ;
23650   Dali::Image *result = 0 ;
23651
23652   arg1 = (Dali::Image *)jarg1;
23653   if (!arg1) {
23654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23655     return 0;
23656   }
23657   {
23658     try {
23659       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23660     } catch (std::out_of_range& e) {
23661       {
23662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23663       };
23664     } catch (std::exception& e) {
23665       {
23666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23667       };
23668     } catch (Dali::DaliException e) {
23669       {
23670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23671       };
23672     } catch (...) {
23673       {
23674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23675       };
23676     }
23677   }
23678
23679   jresult = (void *)result;
23680   return jresult;
23681 }
23682
23683
23684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23685   void * jresult ;
23686   Dali::Image *arg1 = (Dali::Image *) 0 ;
23687   Dali::Image *arg2 = 0 ;
23688   Dali::Image *result = 0 ;
23689
23690   arg1 = (Dali::Image *)jarg1;
23691   arg2 = (Dali::Image *)jarg2;
23692   if (!arg2) {
23693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23694     return 0;
23695   }
23696   {
23697     try {
23698       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23699     } catch (std::out_of_range& e) {
23700       {
23701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23702       };
23703     } catch (std::exception& e) {
23704       {
23705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23706       };
23707     } catch (Dali::DaliException e) {
23708       {
23709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23710       };
23711     } catch (...) {
23712       {
23713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23714       };
23715     }
23716   }
23717
23718   jresult = (void *)result;
23719   return jresult;
23720 }
23721
23722
23723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23724   void * jresult ;
23725   Dali::BaseHandle arg1 ;
23726   Dali::BaseHandle *argp1 ;
23727   Dali::Image result;
23728
23729   argp1 = (Dali::BaseHandle *)jarg1;
23730   if (!argp1) {
23731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23732     return 0;
23733   }
23734   arg1 = *argp1;
23735   {
23736     try {
23737       result = Dali::Image::DownCast(arg1);
23738     } catch (std::out_of_range& e) {
23739       {
23740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23741       };
23742     } catch (std::exception& e) {
23743       {
23744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23745       };
23746     } catch (Dali::DaliException e) {
23747       {
23748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23749       };
23750     } catch (...) {
23751       {
23752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23753       };
23754     }
23755   }
23756
23757   jresult = new Dali::Image((const Dali::Image &)result);
23758   return jresult;
23759 }
23760
23761
23762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23763   unsigned int jresult ;
23764   Dali::Image *arg1 = (Dali::Image *) 0 ;
23765   unsigned int result;
23766
23767   arg1 = (Dali::Image *)jarg1;
23768   {
23769     try {
23770       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23771     } catch (std::out_of_range& e) {
23772       {
23773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23774       };
23775     } catch (std::exception& e) {
23776       {
23777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23778       };
23779     } catch (Dali::DaliException e) {
23780       {
23781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23782       };
23783     } catch (...) {
23784       {
23785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23786       };
23787     }
23788   }
23789
23790   jresult = result;
23791   return jresult;
23792 }
23793
23794
23795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23796   unsigned int jresult ;
23797   Dali::Image *arg1 = (Dali::Image *) 0 ;
23798   unsigned int result;
23799
23800   arg1 = (Dali::Image *)jarg1;
23801   {
23802     try {
23803       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23804     } catch (std::out_of_range& e) {
23805       {
23806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23807       };
23808     } catch (std::exception& e) {
23809       {
23810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23811       };
23812     } catch (Dali::DaliException e) {
23813       {
23814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23815       };
23816     } catch (...) {
23817       {
23818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23819       };
23820     }
23821   }
23822
23823   jresult = result;
23824   return jresult;
23825 }
23826
23827
23828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23829   void * jresult ;
23830   Dali::Image *arg1 = (Dali::Image *) 0 ;
23831   Dali::Image::ImageSignalType *result = 0 ;
23832
23833   arg1 = (Dali::Image *)jarg1;
23834   {
23835     try {
23836       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23837     } catch (std::out_of_range& e) {
23838       {
23839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23840       };
23841     } catch (std::exception& e) {
23842       {
23843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23844       };
23845     } catch (Dali::DaliException e) {
23846       {
23847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23848       };
23849     } catch (...) {
23850       {
23851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23852       };
23853     }
23854   }
23855
23856   jresult = (void *)result;
23857   return jresult;
23858 }
23859
23860
23861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23862   int jresult ;
23863   Dali::Pixel::Format result;
23864
23865   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23866   jresult = (int)result;
23867   return jresult;
23868 }
23869
23870
23871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23872   int jresult ;
23873   Dali::Pixel::Format result;
23874
23875   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23876   jresult = (int)result;
23877   return jresult;
23878 }
23879
23880
23881 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23882   unsigned int jresult ;
23883   Dali::Pixel::Format arg1 ;
23884   bool result;
23885
23886   arg1 = (Dali::Pixel::Format)jarg1;
23887   {
23888     try {
23889       result = (bool)Dali::Pixel::HasAlpha(arg1);
23890     } catch (std::out_of_range& e) {
23891       {
23892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23893       };
23894     } catch (std::exception& e) {
23895       {
23896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23897       };
23898     } catch (Dali::DaliException e) {
23899       {
23900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23901       };
23902     } catch (...) {
23903       {
23904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23905       };
23906     }
23907   }
23908
23909   jresult = result;
23910   return jresult;
23911 }
23912
23913
23914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23915   unsigned int jresult ;
23916   Dali::Pixel::Format arg1 ;
23917   unsigned int result;
23918
23919   arg1 = (Dali::Pixel::Format)jarg1;
23920   {
23921     try {
23922       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23923     } catch (std::out_of_range& e) {
23924       {
23925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23926       };
23927     } catch (std::exception& e) {
23928       {
23929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23930       };
23931     } catch (Dali::DaliException e) {
23932       {
23933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23934       };
23935     } catch (...) {
23936       {
23937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23938       };
23939     }
23940   }
23941
23942   jresult = result;
23943   return jresult;
23944 }
23945
23946
23947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23948   Dali::Pixel::Format arg1 ;
23949   int *arg2 = 0 ;
23950   int *arg3 = 0 ;
23951
23952   arg1 = (Dali::Pixel::Format)jarg1;
23953   arg2 = (int *)jarg2;
23954   if (!arg2) {
23955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23956     return ;
23957   }
23958   arg3 = (int *)jarg3;
23959   if (!arg3) {
23960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23961     return ;
23962   }
23963   {
23964     try {
23965       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23966     } catch (std::out_of_range& e) {
23967       {
23968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23969       };
23970     } catch (std::exception& e) {
23971       {
23972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23973       };
23974     } catch (Dali::DaliException e) {
23975       {
23976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23977       };
23978     } catch (...) {
23979       {
23980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23981       };
23982     }
23983   }
23984
23985 }
23986
23987
23988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23989   void * jresult ;
23990   unsigned char *arg1 = (unsigned char *) 0 ;
23991   unsigned int arg2 ;
23992   unsigned int arg3 ;
23993   unsigned int arg4 ;
23994   Dali::Pixel::Format arg5 ;
23995   Dali::PixelData::ReleaseFunction arg6 ;
23996   Dali::PixelData result;
23997
23998   arg1 = jarg1;
23999   arg2 = (unsigned int)jarg2;
24000   arg3 = (unsigned int)jarg3;
24001   arg4 = (unsigned int)jarg4;
24002   arg5 = (Dali::Pixel::Format)jarg5;
24003   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
24004   {
24005     try {
24006       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
24007     } catch (std::out_of_range& e) {
24008       {
24009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24010       };
24011     } catch (std::exception& e) {
24012       {
24013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24014       };
24015     } catch (Dali::DaliException e) {
24016       {
24017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24018       };
24019     } catch (...) {
24020       {
24021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24022       };
24023     }
24024   }
24025
24026   jresult = new Dali::PixelData((const Dali::PixelData &)result);
24027
24028
24029   return jresult;
24030 }
24031
24032
24033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24034   void * jresult ;
24035   Dali::PixelData *result = 0 ;
24036
24037   {
24038     try {
24039       result = (Dali::PixelData *)new Dali::PixelData();
24040     } catch (std::out_of_range& e) {
24041       {
24042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24043       };
24044     } catch (std::exception& e) {
24045       {
24046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24047       };
24048     } catch (Dali::DaliException e) {
24049       {
24050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24051       };
24052     } catch (...) {
24053       {
24054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24055       };
24056     }
24057   }
24058
24059   jresult = (void *)result;
24060   return jresult;
24061 }
24062
24063
24064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24065   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24066
24067   arg1 = (Dali::PixelData *)jarg1;
24068   {
24069     try {
24070       delete arg1;
24071     } catch (std::out_of_range& e) {
24072       {
24073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24074       };
24075     } catch (std::exception& e) {
24076       {
24077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24078       };
24079     } catch (Dali::DaliException e) {
24080       {
24081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24082       };
24083     } catch (...) {
24084       {
24085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24086       };
24087     }
24088   }
24089
24090 }
24091
24092
24093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24094   void * jresult ;
24095   Dali::PixelData *arg1 = 0 ;
24096   Dali::PixelData *result = 0 ;
24097
24098   arg1 = (Dali::PixelData *)jarg1;
24099   if (!arg1) {
24100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24101     return 0;
24102   }
24103   {
24104     try {
24105       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24106     } catch (std::out_of_range& e) {
24107       {
24108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24109       };
24110     } catch (std::exception& e) {
24111       {
24112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24113       };
24114     } catch (Dali::DaliException e) {
24115       {
24116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24117       };
24118     } catch (...) {
24119       {
24120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24121       };
24122     }
24123   }
24124
24125   jresult = (void *)result;
24126   return jresult;
24127 }
24128
24129
24130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24131   void * jresult ;
24132   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24133   Dali::PixelData *arg2 = 0 ;
24134   Dali::PixelData *result = 0 ;
24135
24136   arg1 = (Dali::PixelData *)jarg1;
24137   arg2 = (Dali::PixelData *)jarg2;
24138   if (!arg2) {
24139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24140     return 0;
24141   }
24142   {
24143     try {
24144       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24145     } catch (std::out_of_range& e) {
24146       {
24147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24148       };
24149     } catch (std::exception& e) {
24150       {
24151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24152       };
24153     } catch (Dali::DaliException e) {
24154       {
24155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24156       };
24157     } catch (...) {
24158       {
24159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24160       };
24161     }
24162   }
24163
24164   jresult = (void *)result;
24165   return jresult;
24166 }
24167
24168
24169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24170   unsigned int jresult ;
24171   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24172   unsigned int result;
24173
24174   arg1 = (Dali::PixelData *)jarg1;
24175   {
24176     try {
24177       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24178     } catch (std::out_of_range& e) {
24179       {
24180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24181       };
24182     } catch (std::exception& e) {
24183       {
24184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24185       };
24186     } catch (Dali::DaliException e) {
24187       {
24188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24189       };
24190     } catch (...) {
24191       {
24192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24193       };
24194     }
24195   }
24196
24197   jresult = result;
24198   return jresult;
24199 }
24200
24201
24202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24203   unsigned int jresult ;
24204   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24205   unsigned int result;
24206
24207   arg1 = (Dali::PixelData *)jarg1;
24208   {
24209     try {
24210       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24211     } catch (std::out_of_range& e) {
24212       {
24213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24214       };
24215     } catch (std::exception& e) {
24216       {
24217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24218       };
24219     } catch (Dali::DaliException e) {
24220       {
24221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24222       };
24223     } catch (...) {
24224       {
24225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24226       };
24227     }
24228   }
24229
24230   jresult = result;
24231   return jresult;
24232 }
24233
24234
24235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24236   int jresult ;
24237   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24238   Dali::Pixel::Format result;
24239
24240   arg1 = (Dali::PixelData *)jarg1;
24241   {
24242     try {
24243       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24244     } catch (std::out_of_range& e) {
24245       {
24246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24247       };
24248     } catch (std::exception& e) {
24249       {
24250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24251       };
24252     } catch (Dali::DaliException e) {
24253       {
24254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24255       };
24256     } catch (...) {
24257       {
24258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24259       };
24260     }
24261   }
24262
24263   jresult = (int)result;
24264   return jresult;
24265 }
24266
24267
24268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24269   unsigned int jresult ;
24270   unsigned int result;
24271
24272   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24273   jresult = result;
24274   return jresult;
24275 }
24276
24277
24278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24279   unsigned int jresult ;
24280   unsigned int result;
24281
24282   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24283   jresult = result;
24284   return jresult;
24285 }
24286
24287
24288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24289   unsigned int jresult ;
24290   unsigned int result;
24291
24292   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24293   jresult = result;
24294   return jresult;
24295 }
24296
24297
24298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24299   unsigned int jresult ;
24300   unsigned int result;
24301
24302   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24303   jresult = result;
24304   return jresult;
24305 }
24306
24307
24308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24309   unsigned int jresult ;
24310   unsigned int result;
24311
24312   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24313   jresult = result;
24314   return jresult;
24315 }
24316
24317
24318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24319   unsigned int jresult ;
24320   unsigned int result;
24321
24322   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24323   jresult = result;
24324   return jresult;
24325 }
24326
24327
24328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24329   void * jresult ;
24330   Dali::TextureType::Type arg1 ;
24331   Dali::Pixel::Format arg2 ;
24332   unsigned int arg3 ;
24333   unsigned int arg4 ;
24334   Dali::Texture result;
24335
24336   arg1 = (Dali::TextureType::Type)jarg1;
24337   arg2 = (Dali::Pixel::Format)jarg2;
24338   arg3 = (unsigned int)jarg3;
24339   arg4 = (unsigned int)jarg4;
24340   {
24341     try {
24342       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24343     } catch (std::out_of_range& e) {
24344       {
24345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24346       };
24347     } catch (std::exception& e) {
24348       {
24349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24350       };
24351     } catch (Dali::DaliException e) {
24352       {
24353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24354       };
24355     } catch (...) {
24356       {
24357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24358       };
24359     }
24360   }
24361
24362   jresult = new Dali::Texture((const Dali::Texture &)result);
24363   return jresult;
24364 }
24365
24366
24367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24368   void * jresult ;
24369   NativeImageInterface *arg1 = 0 ;
24370   Dali::Texture result;
24371
24372   arg1 = (NativeImageInterface *)jarg1;
24373   if (!arg1) {
24374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24375     return 0;
24376   }
24377   {
24378     try {
24379       result = Dali::Texture::New(*arg1);
24380     } catch (std::out_of_range& e) {
24381       {
24382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24383       };
24384     } catch (std::exception& e) {
24385       {
24386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24387       };
24388     } catch (Dali::DaliException e) {
24389       {
24390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24391       };
24392     } catch (...) {
24393       {
24394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24395       };
24396     }
24397   }
24398
24399   jresult = new Dali::Texture((const Dali::Texture &)result);
24400   return jresult;
24401 }
24402
24403
24404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24405   void * jresult ;
24406   Dali::Texture *result = 0 ;
24407
24408   {
24409     try {
24410       result = (Dali::Texture *)new Dali::Texture();
24411     } catch (std::out_of_range& e) {
24412       {
24413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24414       };
24415     } catch (std::exception& e) {
24416       {
24417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24418       };
24419     } catch (Dali::DaliException e) {
24420       {
24421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24422       };
24423     } catch (...) {
24424       {
24425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24426       };
24427     }
24428   }
24429
24430   jresult = (void *)result;
24431   return jresult;
24432 }
24433
24434
24435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24436   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24437
24438   arg1 = (Dali::Texture *)jarg1;
24439   {
24440     try {
24441       delete arg1;
24442     } catch (std::out_of_range& e) {
24443       {
24444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24445       };
24446     } catch (std::exception& e) {
24447       {
24448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24449       };
24450     } catch (Dali::DaliException e) {
24451       {
24452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24453       };
24454     } catch (...) {
24455       {
24456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24457       };
24458     }
24459   }
24460
24461 }
24462
24463
24464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24465   void * jresult ;
24466   Dali::Texture *arg1 = 0 ;
24467   Dali::Texture *result = 0 ;
24468
24469   arg1 = (Dali::Texture *)jarg1;
24470   if (!arg1) {
24471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24472     return 0;
24473   }
24474   {
24475     try {
24476       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24477     } catch (std::out_of_range& e) {
24478       {
24479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24480       };
24481     } catch (std::exception& e) {
24482       {
24483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24484       };
24485     } catch (Dali::DaliException e) {
24486       {
24487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24488       };
24489     } catch (...) {
24490       {
24491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24492       };
24493     }
24494   }
24495
24496   jresult = (void *)result;
24497   return jresult;
24498 }
24499
24500
24501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24502   void * jresult ;
24503   Dali::BaseHandle arg1 ;
24504   Dali::BaseHandle *argp1 ;
24505   Dali::Texture result;
24506
24507   argp1 = (Dali::BaseHandle *)jarg1;
24508   if (!argp1) {
24509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24510     return 0;
24511   }
24512   arg1 = *argp1;
24513   {
24514     try {
24515       result = Dali::Texture::DownCast(arg1);
24516     } catch (std::out_of_range& e) {
24517       {
24518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24519       };
24520     } catch (std::exception& e) {
24521       {
24522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24523       };
24524     } catch (Dali::DaliException e) {
24525       {
24526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24527       };
24528     } catch (...) {
24529       {
24530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24531       };
24532     }
24533   }
24534
24535   jresult = new Dali::Texture((const Dali::Texture &)result);
24536   return jresult;
24537 }
24538
24539
24540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24541   void * jresult ;
24542   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24543   Dali::Texture *arg2 = 0 ;
24544   Dali::Texture *result = 0 ;
24545
24546   arg1 = (Dali::Texture *)jarg1;
24547   arg2 = (Dali::Texture *)jarg2;
24548   if (!arg2) {
24549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24550     return 0;
24551   }
24552   {
24553     try {
24554       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24555     } catch (std::out_of_range& e) {
24556       {
24557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24558       };
24559     } catch (std::exception& e) {
24560       {
24561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24562       };
24563     } catch (Dali::DaliException e) {
24564       {
24565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24566       };
24567     } catch (...) {
24568       {
24569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24570       };
24571     }
24572   }
24573
24574   jresult = (void *)result;
24575   return jresult;
24576 }
24577
24578
24579 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24580   unsigned int jresult ;
24581   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24582   Dali::PixelData arg2 ;
24583   Dali::PixelData *argp2 ;
24584   bool result;
24585
24586   arg1 = (Dali::Texture *)jarg1;
24587   argp2 = (Dali::PixelData *)jarg2;
24588   if (!argp2) {
24589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24590     return 0;
24591   }
24592   arg2 = *argp2;
24593   {
24594     try {
24595       result = (bool)(arg1)->Upload(arg2);
24596     } catch (std::out_of_range& e) {
24597       {
24598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24599       };
24600     } catch (std::exception& e) {
24601       {
24602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24603       };
24604     } catch (Dali::DaliException e) {
24605       {
24606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24607       };
24608     } catch (...) {
24609       {
24610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24611       };
24612     }
24613   }
24614
24615   jresult = result;
24616   return jresult;
24617 }
24618
24619
24620 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) {
24621   unsigned int jresult ;
24622   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24623   Dali::PixelData arg2 ;
24624   unsigned int arg3 ;
24625   unsigned int arg4 ;
24626   unsigned int arg5 ;
24627   unsigned int arg6 ;
24628   unsigned int arg7 ;
24629   unsigned int arg8 ;
24630   Dali::PixelData *argp2 ;
24631   bool result;
24632
24633   arg1 = (Dali::Texture *)jarg1;
24634   argp2 = (Dali::PixelData *)jarg2;
24635   if (!argp2) {
24636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24637     return 0;
24638   }
24639   arg2 = *argp2;
24640   arg3 = (unsigned int)jarg3;
24641   arg4 = (unsigned int)jarg4;
24642   arg5 = (unsigned int)jarg5;
24643   arg6 = (unsigned int)jarg6;
24644   arg7 = (unsigned int)jarg7;
24645   arg8 = (unsigned int)jarg8;
24646   {
24647     try {
24648       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24649     } catch (std::out_of_range& e) {
24650       {
24651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24652       };
24653     } catch (std::exception& e) {
24654       {
24655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24656       };
24657     } catch (Dali::DaliException e) {
24658       {
24659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24660       };
24661     } catch (...) {
24662       {
24663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24664       };
24665     }
24666   }
24667
24668   jresult = result;
24669   return jresult;
24670 }
24671
24672
24673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24674   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24675
24676   arg1 = (Dali::Texture *)jarg1;
24677   {
24678     try {
24679       (arg1)->GenerateMipmaps();
24680     } catch (std::out_of_range& e) {
24681       {
24682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24683       };
24684     } catch (std::exception& e) {
24685       {
24686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24687       };
24688     } catch (Dali::DaliException e) {
24689       {
24690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24691       };
24692     } catch (...) {
24693       {
24694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24695       };
24696     }
24697   }
24698
24699 }
24700
24701
24702 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24703   unsigned int jresult ;
24704   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24705   unsigned int result;
24706
24707   arg1 = (Dali::Texture *)jarg1;
24708   {
24709     try {
24710       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24711     } catch (std::out_of_range& e) {
24712       {
24713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24714       };
24715     } catch (std::exception& e) {
24716       {
24717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24718       };
24719     } catch (Dali::DaliException e) {
24720       {
24721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24722       };
24723     } catch (...) {
24724       {
24725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24726       };
24727     }
24728   }
24729
24730   jresult = result;
24731   return jresult;
24732 }
24733
24734
24735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24736   unsigned int jresult ;
24737   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24738   unsigned int result;
24739
24740   arg1 = (Dali::Texture *)jarg1;
24741   {
24742     try {
24743       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24744     } catch (std::out_of_range& e) {
24745       {
24746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24747       };
24748     } catch (std::exception& e) {
24749       {
24750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24751       };
24752     } catch (Dali::DaliException e) {
24753       {
24754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24755       };
24756     } catch (...) {
24757       {
24758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24759       };
24760     }
24761   }
24762
24763   jresult = result;
24764   return jresult;
24765 }
24766
24767
24768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
24769   void * jresult ;
24770   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
24771   Dali::Texture *result = 0 ;
24772
24773   arg1 = (Dali::Internal::Texture *)jarg1;
24774   {
24775     try {
24776       result = (Dali::Texture *)new Dali::Texture(arg1);
24777     } catch (std::out_of_range& e) {
24778       {
24779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24780       };
24781     } catch (std::exception& e) {
24782       {
24783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24784       };
24785     } catch (Dali::DaliException e) {
24786       {
24787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24788       };
24789     } catch (...) {
24790       {
24791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24792       };
24793     }
24794   }
24795
24796   jresult = (void *)result;
24797   return jresult;
24798 }
24799
24800
24801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24802   void * jresult ;
24803   Dali::Sampler result;
24804
24805   {
24806     try {
24807       result = Dali::Sampler::New();
24808     } catch (std::out_of_range& e) {
24809       {
24810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24811       };
24812     } catch (std::exception& e) {
24813       {
24814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24815       };
24816     } catch (Dali::DaliException e) {
24817       {
24818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24819       };
24820     } catch (...) {
24821       {
24822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24823       };
24824     }
24825   }
24826
24827   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24828   return jresult;
24829 }
24830
24831
24832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24833   void * jresult ;
24834   Dali::Sampler *result = 0 ;
24835
24836   {
24837     try {
24838       result = (Dali::Sampler *)new Dali::Sampler();
24839     } catch (std::out_of_range& e) {
24840       {
24841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24842       };
24843     } catch (std::exception& e) {
24844       {
24845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24846       };
24847     } catch (Dali::DaliException e) {
24848       {
24849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24850       };
24851     } catch (...) {
24852       {
24853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24854       };
24855     }
24856   }
24857
24858   jresult = (void *)result;
24859   return jresult;
24860 }
24861
24862
24863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24864   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24865
24866   arg1 = (Dali::Sampler *)jarg1;
24867   {
24868     try {
24869       delete arg1;
24870     } catch (std::out_of_range& e) {
24871       {
24872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24873       };
24874     } catch (std::exception& e) {
24875       {
24876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24877       };
24878     } catch (Dali::DaliException e) {
24879       {
24880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24881       };
24882     } catch (...) {
24883       {
24884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24885       };
24886     }
24887   }
24888
24889 }
24890
24891
24892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24893   void * jresult ;
24894   Dali::Sampler *arg1 = 0 ;
24895   Dali::Sampler *result = 0 ;
24896
24897   arg1 = (Dali::Sampler *)jarg1;
24898   if (!arg1) {
24899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24900     return 0;
24901   }
24902   {
24903     try {
24904       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24905     } catch (std::out_of_range& e) {
24906       {
24907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24908       };
24909     } catch (std::exception& e) {
24910       {
24911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24912       };
24913     } catch (Dali::DaliException e) {
24914       {
24915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24916       };
24917     } catch (...) {
24918       {
24919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24920       };
24921     }
24922   }
24923
24924   jresult = (void *)result;
24925   return jresult;
24926 }
24927
24928
24929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24930   void * jresult ;
24931   Dali::BaseHandle arg1 ;
24932   Dali::BaseHandle *argp1 ;
24933   Dali::Sampler result;
24934
24935   argp1 = (Dali::BaseHandle *)jarg1;
24936   if (!argp1) {
24937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24938     return 0;
24939   }
24940   arg1 = *argp1;
24941   {
24942     try {
24943       result = Dali::Sampler::DownCast(arg1);
24944     } catch (std::out_of_range& e) {
24945       {
24946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24947       };
24948     } catch (std::exception& e) {
24949       {
24950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24951       };
24952     } catch (Dali::DaliException e) {
24953       {
24954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24955       };
24956     } catch (...) {
24957       {
24958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24959       };
24960     }
24961   }
24962
24963   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24964   return jresult;
24965 }
24966
24967
24968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24969   void * jresult ;
24970   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24971   Dali::Sampler *arg2 = 0 ;
24972   Dali::Sampler *result = 0 ;
24973
24974   arg1 = (Dali::Sampler *)jarg1;
24975   arg2 = (Dali::Sampler *)jarg2;
24976   if (!arg2) {
24977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24978     return 0;
24979   }
24980   {
24981     try {
24982       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24983     } catch (std::out_of_range& e) {
24984       {
24985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24986       };
24987     } catch (std::exception& e) {
24988       {
24989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24990       };
24991     } catch (Dali::DaliException e) {
24992       {
24993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24994       };
24995     } catch (...) {
24996       {
24997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24998       };
24999     }
25000   }
25001
25002   jresult = (void *)result;
25003   return jresult;
25004 }
25005
25006
25007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
25008   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25009   Dali::FilterMode::Type arg2 ;
25010   Dali::FilterMode::Type arg3 ;
25011
25012   arg1 = (Dali::Sampler *)jarg1;
25013   arg2 = (Dali::FilterMode::Type)jarg2;
25014   arg3 = (Dali::FilterMode::Type)jarg3;
25015   {
25016     try {
25017       (arg1)->SetFilterMode(arg2,arg3);
25018     } catch (std::out_of_range& e) {
25019       {
25020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25021       };
25022     } catch (std::exception& e) {
25023       {
25024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25025       };
25026     } catch (Dali::DaliException e) {
25027       {
25028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25029       };
25030     } catch (...) {
25031       {
25032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25033       };
25034     }
25035   }
25036
25037 }
25038
25039
25040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
25041   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25042   Dali::WrapMode::Type arg2 ;
25043   Dali::WrapMode::Type arg3 ;
25044
25045   arg1 = (Dali::Sampler *)jarg1;
25046   arg2 = (Dali::WrapMode::Type)jarg2;
25047   arg3 = (Dali::WrapMode::Type)jarg3;
25048   {
25049     try {
25050       (arg1)->SetWrapMode(arg2,arg3);
25051     } catch (std::out_of_range& e) {
25052       {
25053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25054       };
25055     } catch (std::exception& e) {
25056       {
25057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25058       };
25059     } catch (Dali::DaliException e) {
25060       {
25061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25062       };
25063     } catch (...) {
25064       {
25065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25066       };
25067     }
25068   }
25069
25070 }
25071
25072
25073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25074   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25075   Dali::WrapMode::Type arg2 ;
25076   Dali::WrapMode::Type arg3 ;
25077   Dali::WrapMode::Type arg4 ;
25078
25079   arg1 = (Dali::Sampler *)jarg1;
25080   arg2 = (Dali::WrapMode::Type)jarg2;
25081   arg3 = (Dali::WrapMode::Type)jarg3;
25082   arg4 = (Dali::WrapMode::Type)jarg4;
25083   {
25084     try {
25085       (arg1)->SetWrapMode(arg2,arg3,arg4);
25086     } catch (std::out_of_range& e) {
25087       {
25088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25089       };
25090     } catch (std::exception& e) {
25091       {
25092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25093       };
25094     } catch (Dali::DaliException e) {
25095       {
25096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25097       };
25098     } catch (...) {
25099       {
25100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25101       };
25102     }
25103   }
25104
25105 }
25106
25107
25108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25109   void * jresult ;
25110   Dali::TextureSet result;
25111
25112   {
25113     try {
25114       result = Dali::TextureSet::New();
25115     } catch (std::out_of_range& e) {
25116       {
25117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25118       };
25119     } catch (std::exception& e) {
25120       {
25121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25122       };
25123     } catch (Dali::DaliException e) {
25124       {
25125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25126       };
25127     } catch (...) {
25128       {
25129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25130       };
25131     }
25132   }
25133
25134   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25135   return jresult;
25136 }
25137
25138
25139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25140   void * jresult ;
25141   Dali::TextureSet *result = 0 ;
25142
25143   {
25144     try {
25145       result = (Dali::TextureSet *)new Dali::TextureSet();
25146     } catch (std::out_of_range& e) {
25147       {
25148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25149       };
25150     } catch (std::exception& e) {
25151       {
25152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25153       };
25154     } catch (Dali::DaliException e) {
25155       {
25156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25157       };
25158     } catch (...) {
25159       {
25160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25161       };
25162     }
25163   }
25164
25165   jresult = (void *)result;
25166   return jresult;
25167 }
25168
25169
25170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25171   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25172
25173   arg1 = (Dali::TextureSet *)jarg1;
25174   {
25175     try {
25176       delete arg1;
25177     } catch (std::out_of_range& e) {
25178       {
25179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25180       };
25181     } catch (std::exception& e) {
25182       {
25183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25184       };
25185     } catch (Dali::DaliException e) {
25186       {
25187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25188       };
25189     } catch (...) {
25190       {
25191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25192       };
25193     }
25194   }
25195
25196 }
25197
25198
25199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25200   void * jresult ;
25201   Dali::TextureSet *arg1 = 0 ;
25202   Dali::TextureSet *result = 0 ;
25203
25204   arg1 = (Dali::TextureSet *)jarg1;
25205   if (!arg1) {
25206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25207     return 0;
25208   }
25209   {
25210     try {
25211       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25212     } catch (std::out_of_range& e) {
25213       {
25214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25215       };
25216     } catch (std::exception& e) {
25217       {
25218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25219       };
25220     } catch (Dali::DaliException e) {
25221       {
25222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25223       };
25224     } catch (...) {
25225       {
25226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25227       };
25228     }
25229   }
25230
25231   jresult = (void *)result;
25232   return jresult;
25233 }
25234
25235
25236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25237   void * jresult ;
25238   Dali::BaseHandle arg1 ;
25239   Dali::BaseHandle *argp1 ;
25240   Dali::TextureSet result;
25241
25242   argp1 = (Dali::BaseHandle *)jarg1;
25243   if (!argp1) {
25244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25245     return 0;
25246   }
25247   arg1 = *argp1;
25248   {
25249     try {
25250       result = Dali::TextureSet::DownCast(arg1);
25251     } catch (std::out_of_range& e) {
25252       {
25253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25254       };
25255     } catch (std::exception& e) {
25256       {
25257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25258       };
25259     } catch (Dali::DaliException e) {
25260       {
25261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25262       };
25263     } catch (...) {
25264       {
25265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25266       };
25267     }
25268   }
25269
25270   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25271   return jresult;
25272 }
25273
25274
25275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25276   void * jresult ;
25277   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25278   Dali::TextureSet *arg2 = 0 ;
25279   Dali::TextureSet *result = 0 ;
25280
25281   arg1 = (Dali::TextureSet *)jarg1;
25282   arg2 = (Dali::TextureSet *)jarg2;
25283   if (!arg2) {
25284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25285     return 0;
25286   }
25287   {
25288     try {
25289       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25290     } catch (std::out_of_range& e) {
25291       {
25292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25293       };
25294     } catch (std::exception& e) {
25295       {
25296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25297       };
25298     } catch (Dali::DaliException e) {
25299       {
25300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25301       };
25302     } catch (...) {
25303       {
25304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25305       };
25306     }
25307   }
25308
25309   jresult = (void *)result;
25310   return jresult;
25311 }
25312
25313
25314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25315   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25316   size_t arg2 ;
25317   Dali::Texture arg3 ;
25318   Dali::Texture *argp3 ;
25319
25320   arg1 = (Dali::TextureSet *)jarg1;
25321   arg2 = (size_t)jarg2;
25322   argp3 = (Dali::Texture *)jarg3;
25323   if (!argp3) {
25324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25325     return ;
25326   }
25327   arg3 = *argp3;
25328   {
25329     try {
25330       (arg1)->SetTexture(arg2,arg3);
25331     } catch (std::out_of_range& e) {
25332       {
25333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25334       };
25335     } catch (std::exception& e) {
25336       {
25337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25338       };
25339     } catch (Dali::DaliException e) {
25340       {
25341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25342       };
25343     } catch (...) {
25344       {
25345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25346       };
25347     }
25348   }
25349
25350 }
25351
25352
25353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25354   void * jresult ;
25355   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25356   size_t arg2 ;
25357   Dali::Texture result;
25358
25359   arg1 = (Dali::TextureSet *)jarg1;
25360   arg2 = (size_t)jarg2;
25361   {
25362     try {
25363       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25364     } catch (std::out_of_range& e) {
25365       {
25366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25367       };
25368     } catch (std::exception& e) {
25369       {
25370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25371       };
25372     } catch (Dali::DaliException e) {
25373       {
25374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25375       };
25376     } catch (...) {
25377       {
25378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25379       };
25380     }
25381   }
25382
25383   jresult = new Dali::Texture((const Dali::Texture &)result);
25384   return jresult;
25385 }
25386
25387
25388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25389   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25390   size_t arg2 ;
25391   Dali::Sampler arg3 ;
25392   Dali::Sampler *argp3 ;
25393
25394   arg1 = (Dali::TextureSet *)jarg1;
25395   arg2 = (size_t)jarg2;
25396   argp3 = (Dali::Sampler *)jarg3;
25397   if (!argp3) {
25398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25399     return ;
25400   }
25401   arg3 = *argp3;
25402   {
25403     try {
25404       (arg1)->SetSampler(arg2,arg3);
25405     } catch (std::out_of_range& e) {
25406       {
25407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25408       };
25409     } catch (std::exception& e) {
25410       {
25411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25412       };
25413     } catch (Dali::DaliException e) {
25414       {
25415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25416       };
25417     } catch (...) {
25418       {
25419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25420       };
25421     }
25422   }
25423
25424 }
25425
25426
25427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25428   void * jresult ;
25429   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25430   size_t arg2 ;
25431   Dali::Sampler result;
25432
25433   arg1 = (Dali::TextureSet *)jarg1;
25434   arg2 = (size_t)jarg2;
25435   {
25436     try {
25437       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25438     } catch (std::out_of_range& e) {
25439       {
25440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25441       };
25442     } catch (std::exception& e) {
25443       {
25444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25445       };
25446     } catch (Dali::DaliException e) {
25447       {
25448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25449       };
25450     } catch (...) {
25451       {
25452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25453       };
25454     }
25455   }
25456
25457   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25458   return jresult;
25459 }
25460
25461
25462 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25463   unsigned long jresult ;
25464   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25465   size_t result;
25466
25467   arg1 = (Dali::TextureSet *)jarg1;
25468   {
25469     try {
25470       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25471     } catch (std::out_of_range& e) {
25472       {
25473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25474       };
25475     } catch (std::exception& e) {
25476       {
25477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25478       };
25479     } catch (Dali::DaliException e) {
25480       {
25481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25482       };
25483     } catch (...) {
25484       {
25485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25486       };
25487     }
25488   }
25489
25490   jresult = (unsigned long)result;
25491   return jresult;
25492 }
25493
25494
25495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25496   void * jresult ;
25497   Dali::Property::Map *arg1 = 0 ;
25498   Dali::PropertyBuffer result;
25499
25500   arg1 = (Dali::Property::Map *)jarg1;
25501   if (!arg1) {
25502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25503     return 0;
25504   }
25505   {
25506     try {
25507       result = Dali::PropertyBuffer::New(*arg1);
25508     } catch (std::out_of_range& e) {
25509       {
25510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25511       };
25512     } catch (std::exception& e) {
25513       {
25514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25515       };
25516     } catch (Dali::DaliException e) {
25517       {
25518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25519       };
25520     } catch (...) {
25521       {
25522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25523       };
25524     }
25525   }
25526
25527   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25528   return jresult;
25529 }
25530
25531
25532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25533   void * jresult ;
25534   Dali::PropertyBuffer *result = 0 ;
25535
25536   {
25537     try {
25538       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25539     } catch (std::out_of_range& e) {
25540       {
25541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25542       };
25543     } catch (std::exception& e) {
25544       {
25545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25546       };
25547     } catch (Dali::DaliException e) {
25548       {
25549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25550       };
25551     } catch (...) {
25552       {
25553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25554       };
25555     }
25556   }
25557
25558   jresult = (void *)result;
25559   return jresult;
25560 }
25561
25562
25563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25564   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25565
25566   arg1 = (Dali::PropertyBuffer *)jarg1;
25567   {
25568     try {
25569       delete arg1;
25570     } catch (std::out_of_range& e) {
25571       {
25572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25573       };
25574     } catch (std::exception& e) {
25575       {
25576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25577       };
25578     } catch (Dali::DaliException e) {
25579       {
25580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25581       };
25582     } catch (...) {
25583       {
25584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25585       };
25586     }
25587   }
25588
25589 }
25590
25591
25592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25593   void * jresult ;
25594   Dali::PropertyBuffer *arg1 = 0 ;
25595   Dali::PropertyBuffer *result = 0 ;
25596
25597   arg1 = (Dali::PropertyBuffer *)jarg1;
25598   if (!arg1) {
25599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25600     return 0;
25601   }
25602   {
25603     try {
25604       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25605     } catch (std::out_of_range& e) {
25606       {
25607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25608       };
25609     } catch (std::exception& e) {
25610       {
25611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25612       };
25613     } catch (Dali::DaliException e) {
25614       {
25615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25616       };
25617     } catch (...) {
25618       {
25619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25620       };
25621     }
25622   }
25623
25624   jresult = (void *)result;
25625   return jresult;
25626 }
25627
25628
25629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25630   void * jresult ;
25631   Dali::BaseHandle arg1 ;
25632   Dali::BaseHandle *argp1 ;
25633   Dali::PropertyBuffer result;
25634
25635   argp1 = (Dali::BaseHandle *)jarg1;
25636   if (!argp1) {
25637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25638     return 0;
25639   }
25640   arg1 = *argp1;
25641   {
25642     try {
25643       result = Dali::PropertyBuffer::DownCast(arg1);
25644     } catch (std::out_of_range& e) {
25645       {
25646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25647       };
25648     } catch (std::exception& e) {
25649       {
25650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25651       };
25652     } catch (Dali::DaliException e) {
25653       {
25654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25655       };
25656     } catch (...) {
25657       {
25658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25659       };
25660     }
25661   }
25662
25663   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25664   return jresult;
25665 }
25666
25667
25668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25669   void * jresult ;
25670   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25671   Dali::PropertyBuffer *arg2 = 0 ;
25672   Dali::PropertyBuffer *result = 0 ;
25673
25674   arg1 = (Dali::PropertyBuffer *)jarg1;
25675   arg2 = (Dali::PropertyBuffer *)jarg2;
25676   if (!arg2) {
25677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25678     return 0;
25679   }
25680   {
25681     try {
25682       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25683     } catch (std::out_of_range& e) {
25684       {
25685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25686       };
25687     } catch (std::exception& e) {
25688       {
25689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25690       };
25691     } catch (Dali::DaliException e) {
25692       {
25693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25694       };
25695     } catch (...) {
25696       {
25697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25698       };
25699     }
25700   }
25701
25702   jresult = (void *)result;
25703   return jresult;
25704 }
25705
25706
25707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25708   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25709   void *arg2 = (void *) 0 ;
25710   std::size_t arg3 ;
25711
25712   arg1 = (Dali::PropertyBuffer *)jarg1;
25713   arg2 = jarg2;
25714   arg3 = (std::size_t)jarg3;
25715   {
25716     try {
25717       (arg1)->SetData((void const *)arg2,arg3);
25718     } catch (std::out_of_range& e) {
25719       {
25720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25721       };
25722     } catch (std::exception& e) {
25723       {
25724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25725       };
25726     } catch (Dali::DaliException e) {
25727       {
25728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25729       };
25730     } catch (...) {
25731       {
25732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25733       };
25734     }
25735   }
25736
25737 }
25738
25739
25740 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25741   unsigned long jresult ;
25742   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25743   std::size_t result;
25744
25745   arg1 = (Dali::PropertyBuffer *)jarg1;
25746   {
25747     try {
25748       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25749     } catch (std::out_of_range& e) {
25750       {
25751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25752       };
25753     } catch (std::exception& e) {
25754       {
25755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25756       };
25757     } catch (Dali::DaliException e) {
25758       {
25759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25760       };
25761     } catch (...) {
25762       {
25763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25764       };
25765     }
25766   }
25767
25768   jresult = (unsigned long)result;
25769   return jresult;
25770 }
25771
25772
25773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25774   void * jresult ;
25775   Dali::Geometry result;
25776
25777   {
25778     try {
25779       result = Dali::Geometry::New();
25780     } catch (std::out_of_range& e) {
25781       {
25782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25783       };
25784     } catch (std::exception& e) {
25785       {
25786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25787       };
25788     } catch (Dali::DaliException e) {
25789       {
25790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25791       };
25792     } catch (...) {
25793       {
25794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25795       };
25796     }
25797   }
25798
25799   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25800   return jresult;
25801 }
25802
25803
25804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25805   void * jresult ;
25806   Dali::Geometry *result = 0 ;
25807
25808   {
25809     try {
25810       result = (Dali::Geometry *)new Dali::Geometry();
25811     } catch (std::out_of_range& e) {
25812       {
25813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25814       };
25815     } catch (std::exception& e) {
25816       {
25817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25818       };
25819     } catch (Dali::DaliException e) {
25820       {
25821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25822       };
25823     } catch (...) {
25824       {
25825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25826       };
25827     }
25828   }
25829
25830   jresult = (void *)result;
25831   return jresult;
25832 }
25833
25834
25835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25836   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25837
25838   arg1 = (Dali::Geometry *)jarg1;
25839   {
25840     try {
25841       delete arg1;
25842     } catch (std::out_of_range& e) {
25843       {
25844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25845       };
25846     } catch (std::exception& e) {
25847       {
25848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25849       };
25850     } catch (Dali::DaliException e) {
25851       {
25852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25853       };
25854     } catch (...) {
25855       {
25856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25857       };
25858     }
25859   }
25860
25861 }
25862
25863
25864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25865   void * jresult ;
25866   Dali::Geometry *arg1 = 0 ;
25867   Dali::Geometry *result = 0 ;
25868
25869   arg1 = (Dali::Geometry *)jarg1;
25870   if (!arg1) {
25871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25872     return 0;
25873   }
25874   {
25875     try {
25876       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25877     } catch (std::out_of_range& e) {
25878       {
25879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25880       };
25881     } catch (std::exception& e) {
25882       {
25883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25884       };
25885     } catch (Dali::DaliException e) {
25886       {
25887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25888       };
25889     } catch (...) {
25890       {
25891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25892       };
25893     }
25894   }
25895
25896   jresult = (void *)result;
25897   return jresult;
25898 }
25899
25900
25901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25902   void * jresult ;
25903   Dali::BaseHandle arg1 ;
25904   Dali::BaseHandle *argp1 ;
25905   Dali::Geometry result;
25906
25907   argp1 = (Dali::BaseHandle *)jarg1;
25908   if (!argp1) {
25909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25910     return 0;
25911   }
25912   arg1 = *argp1;
25913   {
25914     try {
25915       result = Dali::Geometry::DownCast(arg1);
25916     } catch (std::out_of_range& e) {
25917       {
25918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25919       };
25920     } catch (std::exception& e) {
25921       {
25922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25923       };
25924     } catch (Dali::DaliException e) {
25925       {
25926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25927       };
25928     } catch (...) {
25929       {
25930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25931       };
25932     }
25933   }
25934
25935   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25936   return jresult;
25937 }
25938
25939
25940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25941   void * jresult ;
25942   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25943   Dali::Geometry *arg2 = 0 ;
25944   Dali::Geometry *result = 0 ;
25945
25946   arg1 = (Dali::Geometry *)jarg1;
25947   arg2 = (Dali::Geometry *)jarg2;
25948   if (!arg2) {
25949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25950     return 0;
25951   }
25952   {
25953     try {
25954       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25955     } catch (std::out_of_range& e) {
25956       {
25957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25958       };
25959     } catch (std::exception& e) {
25960       {
25961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25962       };
25963     } catch (Dali::DaliException e) {
25964       {
25965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25966       };
25967     } catch (...) {
25968       {
25969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25970       };
25971     }
25972   }
25973
25974   jresult = (void *)result;
25975   return jresult;
25976 }
25977
25978
25979 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25980   unsigned long jresult ;
25981   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25982   Dali::PropertyBuffer *arg2 = 0 ;
25983   std::size_t result;
25984
25985   arg1 = (Dali::Geometry *)jarg1;
25986   arg2 = (Dali::PropertyBuffer *)jarg2;
25987   if (!arg2) {
25988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25989     return 0;
25990   }
25991   {
25992     try {
25993       result = (arg1)->AddVertexBuffer(*arg2);
25994     } catch (std::out_of_range& e) {
25995       {
25996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25997       };
25998     } catch (std::exception& e) {
25999       {
26000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26001       };
26002     } catch (Dali::DaliException e) {
26003       {
26004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26005       };
26006     } catch (...) {
26007       {
26008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26009       };
26010     }
26011   }
26012
26013   jresult = (unsigned long)result;
26014   return jresult;
26015 }
26016
26017
26018 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
26019   unsigned long jresult ;
26020   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26021   std::size_t result;
26022
26023   arg1 = (Dali::Geometry *)jarg1;
26024   {
26025     try {
26026       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
26027     } catch (std::out_of_range& e) {
26028       {
26029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26030       };
26031     } catch (std::exception& e) {
26032       {
26033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26034       };
26035     } catch (Dali::DaliException e) {
26036       {
26037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26038       };
26039     } catch (...) {
26040       {
26041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26042       };
26043     }
26044   }
26045
26046   jresult = (unsigned long)result;
26047   return jresult;
26048 }
26049
26050
26051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
26052   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26053   std::size_t arg2 ;
26054
26055   arg1 = (Dali::Geometry *)jarg1;
26056   arg2 = (std::size_t)jarg2;
26057   {
26058     try {
26059       (arg1)->RemoveVertexBuffer(arg2);
26060     } catch (std::out_of_range& e) {
26061       {
26062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26063       };
26064     } catch (std::exception& e) {
26065       {
26066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26067       };
26068     } catch (Dali::DaliException e) {
26069       {
26070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26071       };
26072     } catch (...) {
26073       {
26074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26075       };
26076     }
26077   }
26078
26079 }
26080
26081
26082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26083   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26084   unsigned short *arg2 = (unsigned short *) 0 ;
26085   size_t arg3 ;
26086
26087   arg1 = (Dali::Geometry *)jarg1;
26088   arg2 = jarg2;
26089   arg3 = (size_t)jarg3;
26090   {
26091     try {
26092       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26093     } catch (std::out_of_range& e) {
26094       {
26095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26096       };
26097     } catch (std::exception& e) {
26098       {
26099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26100       };
26101     } catch (Dali::DaliException e) {
26102       {
26103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26104       };
26105     } catch (...) {
26106       {
26107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26108       };
26109     }
26110   }
26111
26112
26113
26114 }
26115
26116
26117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26118   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26119   Dali::Geometry::Type arg2 ;
26120
26121   arg1 = (Dali::Geometry *)jarg1;
26122   arg2 = (Dali::Geometry::Type)jarg2;
26123   {
26124     try {
26125       (arg1)->SetType(arg2);
26126     } catch (std::out_of_range& e) {
26127       {
26128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26129       };
26130     } catch (std::exception& e) {
26131       {
26132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26133       };
26134     } catch (Dali::DaliException e) {
26135       {
26136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26137       };
26138     } catch (...) {
26139       {
26140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26141       };
26142     }
26143   }
26144
26145 }
26146
26147
26148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26149   int jresult ;
26150   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26151   Dali::Geometry::Type result;
26152
26153   arg1 = (Dali::Geometry *)jarg1;
26154   {
26155     try {
26156       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26157     } catch (std::out_of_range& e) {
26158       {
26159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26160       };
26161     } catch (std::exception& e) {
26162       {
26163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26164       };
26165     } catch (Dali::DaliException e) {
26166       {
26167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26168       };
26169     } catch (...) {
26170       {
26171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26172       };
26173     }
26174   }
26175
26176   jresult = (int)result;
26177   return jresult;
26178 }
26179
26180
26181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26182   void * jresult ;
26183   Dali::Shader::Hint *result = 0 ;
26184
26185   {
26186     try {
26187       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26188     } catch (std::out_of_range& e) {
26189       {
26190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26191       };
26192     } catch (std::exception& e) {
26193       {
26194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26195       };
26196     } catch (Dali::DaliException e) {
26197       {
26198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26199       };
26200     } catch (...) {
26201       {
26202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26203       };
26204     }
26205   }
26206
26207   jresult = (void *)result;
26208   return jresult;
26209 }
26210
26211
26212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26213   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26214
26215   arg1 = (Dali::Shader::Hint *)jarg1;
26216   {
26217     try {
26218       delete arg1;
26219     } catch (std::out_of_range& e) {
26220       {
26221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26222       };
26223     } catch (std::exception& e) {
26224       {
26225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26226       };
26227     } catch (Dali::DaliException e) {
26228       {
26229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26230       };
26231     } catch (...) {
26232       {
26233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26234       };
26235     }
26236   }
26237
26238 }
26239
26240
26241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26242   int jresult ;
26243   int result;
26244
26245   result = (int)Dali::Shader::Property::PROGRAM;
26246   jresult = (int)result;
26247   return jresult;
26248 }
26249
26250
26251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26252   void * jresult ;
26253   Dali::Shader::Property *result = 0 ;
26254
26255   {
26256     try {
26257       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26258     } catch (std::out_of_range& e) {
26259       {
26260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26261       };
26262     } catch (std::exception& e) {
26263       {
26264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26265       };
26266     } catch (Dali::DaliException e) {
26267       {
26268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26269       };
26270     } catch (...) {
26271       {
26272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26273       };
26274     }
26275   }
26276
26277   jresult = (void *)result;
26278   return jresult;
26279 }
26280
26281
26282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26283   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26284
26285   arg1 = (Dali::Shader::Property *)jarg1;
26286   {
26287     try {
26288       delete arg1;
26289     } catch (std::out_of_range& e) {
26290       {
26291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26292       };
26293     } catch (std::exception& e) {
26294       {
26295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26296       };
26297     } catch (Dali::DaliException e) {
26298       {
26299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26300       };
26301     } catch (...) {
26302       {
26303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26304       };
26305     }
26306   }
26307
26308 }
26309
26310
26311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26312   void * jresult ;
26313   std::string *arg1 = 0 ;
26314   std::string *arg2 = 0 ;
26315   Dali::Shader::Hint::Value arg3 ;
26316   Dali::Shader result;
26317
26318   if (!jarg1) {
26319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26320     return 0;
26321   }
26322   std::string arg1_str(jarg1);
26323   arg1 = &arg1_str;
26324   if (!jarg2) {
26325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26326     return 0;
26327   }
26328   std::string arg2_str(jarg2);
26329   arg2 = &arg2_str;
26330   arg3 = (Dali::Shader::Hint::Value)jarg3;
26331   {
26332     try {
26333       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26334     } catch (std::out_of_range& e) {
26335       {
26336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26337       };
26338     } catch (std::exception& e) {
26339       {
26340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26341       };
26342     } catch (Dali::DaliException e) {
26343       {
26344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26345       };
26346     } catch (...) {
26347       {
26348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26349       };
26350     }
26351   }
26352
26353   jresult = new Dali::Shader((const Dali::Shader &)result);
26354
26355   //argout typemap for const std::string&
26356
26357
26358   //argout typemap for const std::string&
26359
26360   return jresult;
26361 }
26362
26363
26364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26365   void * jresult ;
26366   std::string *arg1 = 0 ;
26367   std::string *arg2 = 0 ;
26368   Dali::Shader result;
26369
26370   if (!jarg1) {
26371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26372     return 0;
26373   }
26374   std::string arg1_str(jarg1);
26375   arg1 = &arg1_str;
26376   if (!jarg2) {
26377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26378     return 0;
26379   }
26380   std::string arg2_str(jarg2);
26381   arg2 = &arg2_str;
26382   {
26383     try {
26384       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26385     } catch (std::out_of_range& e) {
26386       {
26387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26388       };
26389     } catch (std::exception& e) {
26390       {
26391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26392       };
26393     } catch (Dali::DaliException e) {
26394       {
26395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26396       };
26397     } catch (...) {
26398       {
26399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26400       };
26401     }
26402   }
26403
26404   jresult = new Dali::Shader((const Dali::Shader &)result);
26405
26406   //argout typemap for const std::string&
26407
26408
26409   //argout typemap for const std::string&
26410
26411   return jresult;
26412 }
26413
26414
26415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26416   void * jresult ;
26417   Dali::Shader *result = 0 ;
26418
26419   {
26420     try {
26421       result = (Dali::Shader *)new Dali::Shader();
26422     } catch (std::out_of_range& e) {
26423       {
26424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26425       };
26426     } catch (std::exception& e) {
26427       {
26428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26429       };
26430     } catch (Dali::DaliException e) {
26431       {
26432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26433       };
26434     } catch (...) {
26435       {
26436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26437       };
26438     }
26439   }
26440
26441   jresult = (void *)result;
26442   return jresult;
26443 }
26444
26445
26446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26447   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26448
26449   arg1 = (Dali::Shader *)jarg1;
26450   {
26451     try {
26452       delete arg1;
26453     } catch (std::out_of_range& e) {
26454       {
26455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26456       };
26457     } catch (std::exception& e) {
26458       {
26459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26460       };
26461     } catch (Dali::DaliException e) {
26462       {
26463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26464       };
26465     } catch (...) {
26466       {
26467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26468       };
26469     }
26470   }
26471
26472 }
26473
26474
26475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26476   void * jresult ;
26477   Dali::Shader *arg1 = 0 ;
26478   Dali::Shader *result = 0 ;
26479
26480   arg1 = (Dali::Shader *)jarg1;
26481   if (!arg1) {
26482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26483     return 0;
26484   }
26485   {
26486     try {
26487       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26488     } catch (std::out_of_range& e) {
26489       {
26490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26491       };
26492     } catch (std::exception& e) {
26493       {
26494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26495       };
26496     } catch (Dali::DaliException e) {
26497       {
26498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26499       };
26500     } catch (...) {
26501       {
26502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26503       };
26504     }
26505   }
26506
26507   jresult = (void *)result;
26508   return jresult;
26509 }
26510
26511
26512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26513   void * jresult ;
26514   Dali::BaseHandle arg1 ;
26515   Dali::BaseHandle *argp1 ;
26516   Dali::Shader result;
26517
26518   argp1 = (Dali::BaseHandle *)jarg1;
26519   if (!argp1) {
26520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26521     return 0;
26522   }
26523   arg1 = *argp1;
26524   {
26525     try {
26526       result = Dali::Shader::DownCast(arg1);
26527     } catch (std::out_of_range& e) {
26528       {
26529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26530       };
26531     } catch (std::exception& e) {
26532       {
26533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26534       };
26535     } catch (Dali::DaliException e) {
26536       {
26537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26538       };
26539     } catch (...) {
26540       {
26541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26542       };
26543     }
26544   }
26545
26546   jresult = new Dali::Shader((const Dali::Shader &)result);
26547   return jresult;
26548 }
26549
26550
26551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26552   void * jresult ;
26553   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26554   Dali::Shader *arg2 = 0 ;
26555   Dali::Shader *result = 0 ;
26556
26557   arg1 = (Dali::Shader *)jarg1;
26558   arg2 = (Dali::Shader *)jarg2;
26559   if (!arg2) {
26560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26561     return 0;
26562   }
26563   {
26564     try {
26565       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26566     } catch (std::out_of_range& e) {
26567       {
26568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26569       };
26570     } catch (std::exception& e) {
26571       {
26572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26573       };
26574     } catch (Dali::DaliException e) {
26575       {
26576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26577       };
26578     } catch (...) {
26579       {
26580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26581       };
26582     }
26583   }
26584
26585   jresult = (void *)result;
26586   return jresult;
26587 }
26588
26589
26590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26591   int jresult ;
26592   int result;
26593
26594   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26595   jresult = (int)result;
26596   return jresult;
26597 }
26598
26599
26600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26601   int jresult ;
26602   int result;
26603
26604   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26605   jresult = (int)result;
26606   return jresult;
26607 }
26608
26609
26610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26611   int jresult ;
26612   int result;
26613
26614   result = (int)Dali::Renderer::Property::BLEND_MODE;
26615   jresult = (int)result;
26616   return jresult;
26617 }
26618
26619
26620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26621   int jresult ;
26622   int result;
26623
26624   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26625   jresult = (int)result;
26626   return jresult;
26627 }
26628
26629
26630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26631   int jresult ;
26632   int result;
26633
26634   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26635   jresult = (int)result;
26636   return jresult;
26637 }
26638
26639
26640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26641   int jresult ;
26642   int result;
26643
26644   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26645   jresult = (int)result;
26646   return jresult;
26647 }
26648
26649
26650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26651   int jresult ;
26652   int result;
26653
26654   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26655   jresult = (int)result;
26656   return jresult;
26657 }
26658
26659
26660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26661   int jresult ;
26662   int result;
26663
26664   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26665   jresult = (int)result;
26666   return jresult;
26667 }
26668
26669
26670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26671   int jresult ;
26672   int result;
26673
26674   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26675   jresult = (int)result;
26676   return jresult;
26677 }
26678
26679
26680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26681   int jresult ;
26682   int result;
26683
26684   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26685   jresult = (int)result;
26686   return jresult;
26687 }
26688
26689
26690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26691   int jresult ;
26692   int result;
26693
26694   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26695   jresult = (int)result;
26696   return jresult;
26697 }
26698
26699
26700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26701   int jresult ;
26702   int result;
26703
26704   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26705   jresult = (int)result;
26706   return jresult;
26707 }
26708
26709
26710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26711   int jresult ;
26712   int result;
26713
26714   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26715   jresult = (int)result;
26716   return jresult;
26717 }
26718
26719
26720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26721   int jresult ;
26722   int result;
26723
26724   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26725   jresult = (int)result;
26726   return jresult;
26727 }
26728
26729
26730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26731   int jresult ;
26732   int result;
26733
26734   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26735   jresult = (int)result;
26736   return jresult;
26737 }
26738
26739
26740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26741   int jresult ;
26742   int result;
26743
26744   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26745   jresult = (int)result;
26746   return jresult;
26747 }
26748
26749
26750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26751   int jresult ;
26752   int result;
26753
26754   result = (int)Dali::Renderer::Property::RENDER_MODE;
26755   jresult = (int)result;
26756   return jresult;
26757 }
26758
26759
26760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26761   int jresult ;
26762   int result;
26763
26764   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26765   jresult = (int)result;
26766   return jresult;
26767 }
26768
26769
26770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26771   int jresult ;
26772   int result;
26773
26774   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26775   jresult = (int)result;
26776   return jresult;
26777 }
26778
26779
26780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26781   int jresult ;
26782   int result;
26783
26784   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26785   jresult = (int)result;
26786   return jresult;
26787 }
26788
26789
26790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26791   int jresult ;
26792   int result;
26793
26794   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26795   jresult = (int)result;
26796   return jresult;
26797 }
26798
26799
26800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26801   int jresult ;
26802   int result;
26803
26804   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26805   jresult = (int)result;
26806   return jresult;
26807 }
26808
26809
26810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26811   int jresult ;
26812   int result;
26813
26814   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26815   jresult = (int)result;
26816   return jresult;
26817 }
26818
26819
26820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26821   int jresult ;
26822   int result;
26823
26824   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26825   jresult = (int)result;
26826   return jresult;
26827 }
26828
26829
26830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26831   void * jresult ;
26832   Dali::Renderer::Property *result = 0 ;
26833
26834   {
26835     try {
26836       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26837     } catch (std::out_of_range& e) {
26838       {
26839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26840       };
26841     } catch (std::exception& e) {
26842       {
26843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26844       };
26845     } catch (Dali::DaliException e) {
26846       {
26847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26848       };
26849     } catch (...) {
26850       {
26851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26852       };
26853     }
26854   }
26855
26856   jresult = (void *)result;
26857   return jresult;
26858 }
26859
26860
26861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26862   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26863
26864   arg1 = (Dali::Renderer::Property *)jarg1;
26865   {
26866     try {
26867       delete arg1;
26868     } catch (std::out_of_range& e) {
26869       {
26870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26871       };
26872     } catch (std::exception& e) {
26873       {
26874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26875       };
26876     } catch (Dali::DaliException e) {
26877       {
26878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26879       };
26880     } catch (...) {
26881       {
26882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26883       };
26884     }
26885   }
26886
26887 }
26888
26889
26890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26891   void * jresult ;
26892   Dali::Geometry *arg1 = 0 ;
26893   Dali::Shader *arg2 = 0 ;
26894   Dali::Renderer result;
26895
26896   arg1 = (Dali::Geometry *)jarg1;
26897   if (!arg1) {
26898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26899     return 0;
26900   }
26901   arg2 = (Dali::Shader *)jarg2;
26902   if (!arg2) {
26903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26904     return 0;
26905   }
26906   {
26907     try {
26908       result = Dali::Renderer::New(*arg1,*arg2);
26909     } catch (std::out_of_range& e) {
26910       {
26911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26912       };
26913     } catch (std::exception& e) {
26914       {
26915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26916       };
26917     } catch (Dali::DaliException e) {
26918       {
26919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26920       };
26921     } catch (...) {
26922       {
26923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26924       };
26925     }
26926   }
26927
26928   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26929   return jresult;
26930 }
26931
26932
26933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26934   void * jresult ;
26935   Dali::Renderer *result = 0 ;
26936
26937   {
26938     try {
26939       result = (Dali::Renderer *)new Dali::Renderer();
26940     } catch (std::out_of_range& e) {
26941       {
26942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26943       };
26944     } catch (std::exception& e) {
26945       {
26946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26947       };
26948     } catch (Dali::DaliException e) {
26949       {
26950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26951       };
26952     } catch (...) {
26953       {
26954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26955       };
26956     }
26957   }
26958
26959   jresult = (void *)result;
26960   return jresult;
26961 }
26962
26963
26964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26965   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26966
26967   arg1 = (Dali::Renderer *)jarg1;
26968   {
26969     try {
26970       delete arg1;
26971     } catch (std::out_of_range& e) {
26972       {
26973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26974       };
26975     } catch (std::exception& e) {
26976       {
26977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26978       };
26979     } catch (Dali::DaliException e) {
26980       {
26981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26982       };
26983     } catch (...) {
26984       {
26985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26986       };
26987     }
26988   }
26989
26990 }
26991
26992
26993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26994   void * jresult ;
26995   Dali::Renderer *arg1 = 0 ;
26996   Dali::Renderer *result = 0 ;
26997
26998   arg1 = (Dali::Renderer *)jarg1;
26999   if (!arg1) {
27000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27001     return 0;
27002   }
27003   {
27004     try {
27005       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
27006     } catch (std::out_of_range& e) {
27007       {
27008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27009       };
27010     } catch (std::exception& e) {
27011       {
27012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27013       };
27014     } catch (Dali::DaliException e) {
27015       {
27016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27017       };
27018     } catch (...) {
27019       {
27020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27021       };
27022     }
27023   }
27024
27025   jresult = (void *)result;
27026   return jresult;
27027 }
27028
27029
27030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
27031   void * jresult ;
27032   Dali::BaseHandle arg1 ;
27033   Dali::BaseHandle *argp1 ;
27034   Dali::Renderer result;
27035
27036   argp1 = (Dali::BaseHandle *)jarg1;
27037   if (!argp1) {
27038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27039     return 0;
27040   }
27041   arg1 = *argp1;
27042   {
27043     try {
27044       result = Dali::Renderer::DownCast(arg1);
27045     } catch (std::out_of_range& e) {
27046       {
27047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27048       };
27049     } catch (std::exception& e) {
27050       {
27051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27052       };
27053     } catch (Dali::DaliException e) {
27054       {
27055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27056       };
27057     } catch (...) {
27058       {
27059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27060       };
27061     }
27062   }
27063
27064   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27065   return jresult;
27066 }
27067
27068
27069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27070   void * jresult ;
27071   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27072   Dali::Renderer *arg2 = 0 ;
27073   Dali::Renderer *result = 0 ;
27074
27075   arg1 = (Dali::Renderer *)jarg1;
27076   arg2 = (Dali::Renderer *)jarg2;
27077   if (!arg2) {
27078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27079     return 0;
27080   }
27081   {
27082     try {
27083       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27084     } catch (std::out_of_range& e) {
27085       {
27086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27087       };
27088     } catch (std::exception& e) {
27089       {
27090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27091       };
27092     } catch (Dali::DaliException e) {
27093       {
27094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27095       };
27096     } catch (...) {
27097       {
27098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27099       };
27100     }
27101   }
27102
27103   jresult = (void *)result;
27104   return jresult;
27105 }
27106
27107
27108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27109   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27110   Dali::Geometry *arg2 = 0 ;
27111
27112   arg1 = (Dali::Renderer *)jarg1;
27113   arg2 = (Dali::Geometry *)jarg2;
27114   if (!arg2) {
27115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27116     return ;
27117   }
27118   {
27119     try {
27120       (arg1)->SetGeometry(*arg2);
27121     } catch (std::out_of_range& e) {
27122       {
27123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27124       };
27125     } catch (std::exception& e) {
27126       {
27127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27128       };
27129     } catch (Dali::DaliException e) {
27130       {
27131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27132       };
27133     } catch (...) {
27134       {
27135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27136       };
27137     }
27138   }
27139
27140 }
27141
27142
27143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27144   void * jresult ;
27145   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27146   Dali::Geometry result;
27147
27148   arg1 = (Dali::Renderer *)jarg1;
27149   {
27150     try {
27151       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27152     } catch (std::out_of_range& e) {
27153       {
27154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27155       };
27156     } catch (std::exception& e) {
27157       {
27158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27159       };
27160     } catch (Dali::DaliException e) {
27161       {
27162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27163       };
27164     } catch (...) {
27165       {
27166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27167       };
27168     }
27169   }
27170
27171   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27172   return jresult;
27173 }
27174
27175
27176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27177   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27178   int arg2 ;
27179   int arg3 ;
27180
27181   arg1 = (Dali::Renderer *)jarg1;
27182   arg2 = (int)jarg2;
27183   arg3 = (int)jarg3;
27184   {
27185     try {
27186       (arg1)->SetIndexRange(arg2,arg3);
27187     } catch (std::out_of_range& e) {
27188       {
27189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27190       };
27191     } catch (std::exception& e) {
27192       {
27193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27194       };
27195     } catch (Dali::DaliException e) {
27196       {
27197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27198       };
27199     } catch (...) {
27200       {
27201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27202       };
27203     }
27204   }
27205
27206 }
27207
27208
27209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27210   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27211   Dali::TextureSet *arg2 = 0 ;
27212
27213   arg1 = (Dali::Renderer *)jarg1;
27214   arg2 = (Dali::TextureSet *)jarg2;
27215   if (!arg2) {
27216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27217     return ;
27218   }
27219   {
27220     try {
27221       (arg1)->SetTextures(*arg2);
27222     } catch (std::out_of_range& e) {
27223       {
27224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27225       };
27226     } catch (std::exception& e) {
27227       {
27228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27229       };
27230     } catch (Dali::DaliException e) {
27231       {
27232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27233       };
27234     } catch (...) {
27235       {
27236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27237       };
27238     }
27239   }
27240
27241 }
27242
27243
27244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27245   void * jresult ;
27246   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27247   Dali::TextureSet result;
27248
27249   arg1 = (Dali::Renderer *)jarg1;
27250   {
27251     try {
27252       result = ((Dali::Renderer const *)arg1)->GetTextures();
27253     } catch (std::out_of_range& e) {
27254       {
27255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27256       };
27257     } catch (std::exception& e) {
27258       {
27259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27260       };
27261     } catch (Dali::DaliException e) {
27262       {
27263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27264       };
27265     } catch (...) {
27266       {
27267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27268       };
27269     }
27270   }
27271
27272   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27273   return jresult;
27274 }
27275
27276
27277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27278   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27279   Dali::Shader *arg2 = 0 ;
27280
27281   arg1 = (Dali::Renderer *)jarg1;
27282   arg2 = (Dali::Shader *)jarg2;
27283   if (!arg2) {
27284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27285     return ;
27286   }
27287   {
27288     try {
27289       (arg1)->SetShader(*arg2);
27290     } catch (std::out_of_range& e) {
27291       {
27292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27293       };
27294     } catch (std::exception& e) {
27295       {
27296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27297       };
27298     } catch (Dali::DaliException e) {
27299       {
27300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27301       };
27302     } catch (...) {
27303       {
27304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27305       };
27306     }
27307   }
27308
27309 }
27310
27311
27312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27313   void * jresult ;
27314   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27315   Dali::Shader result;
27316
27317   arg1 = (Dali::Renderer *)jarg1;
27318   {
27319     try {
27320       result = ((Dali::Renderer const *)arg1)->GetShader();
27321     } catch (std::out_of_range& e) {
27322       {
27323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27324       };
27325     } catch (std::exception& e) {
27326       {
27327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27328       };
27329     } catch (Dali::DaliException e) {
27330       {
27331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27332       };
27333     } catch (...) {
27334       {
27335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27336       };
27337     }
27338   }
27339
27340   jresult = new Dali::Shader((const Dali::Shader &)result);
27341   return jresult;
27342 }
27343
27344
27345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27346   void * jresult ;
27347   Dali::FrameBuffer::Attachment *result = 0 ;
27348
27349   {
27350     try {
27351       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27352     } catch (std::out_of_range& e) {
27353       {
27354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27355       };
27356     } catch (std::exception& e) {
27357       {
27358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27359       };
27360     } catch (Dali::DaliException e) {
27361       {
27362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27363       };
27364     } catch (...) {
27365       {
27366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27367       };
27368     }
27369   }
27370
27371   jresult = (void *)result;
27372   return jresult;
27373 }
27374
27375
27376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27377   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27378
27379   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27380   {
27381     try {
27382       delete arg1;
27383     } catch (std::out_of_range& e) {
27384       {
27385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27386       };
27387     } catch (std::exception& e) {
27388       {
27389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27390       };
27391     } catch (Dali::DaliException e) {
27392       {
27393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27394       };
27395     } catch (...) {
27396       {
27397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27398       };
27399     }
27400   }
27401
27402 }
27403
27404
27405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27406   void * jresult ;
27407   unsigned int arg1 ;
27408   unsigned int arg2 ;
27409   unsigned int arg3 ;
27410   Dali::FrameBuffer result;
27411
27412   arg1 = (unsigned int)jarg1;
27413   arg2 = (unsigned int)jarg2;
27414   arg3 = (unsigned int)jarg3;
27415   {
27416     try {
27417       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27418     } catch (std::out_of_range& e) {
27419       {
27420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27421       };
27422     } catch (std::exception& e) {
27423       {
27424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27425       };
27426     } catch (Dali::DaliException e) {
27427       {
27428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27429       };
27430     } catch (...) {
27431       {
27432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27433       };
27434     }
27435   }
27436
27437   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27438   return jresult;
27439 }
27440
27441
27442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27443   void * jresult ;
27444   Dali::FrameBuffer *result = 0 ;
27445
27446   {
27447     try {
27448       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27449     } catch (std::out_of_range& e) {
27450       {
27451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27452       };
27453     } catch (std::exception& e) {
27454       {
27455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27456       };
27457     } catch (Dali::DaliException e) {
27458       {
27459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27460       };
27461     } catch (...) {
27462       {
27463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27464       };
27465     }
27466   }
27467
27468   jresult = (void *)result;
27469   return jresult;
27470 }
27471
27472
27473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27474   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27475
27476   arg1 = (Dali::FrameBuffer *)jarg1;
27477   {
27478     try {
27479       delete arg1;
27480     } catch (std::out_of_range& e) {
27481       {
27482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27483       };
27484     } catch (std::exception& e) {
27485       {
27486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27487       };
27488     } catch (Dali::DaliException e) {
27489       {
27490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27491       };
27492     } catch (...) {
27493       {
27494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27495       };
27496     }
27497   }
27498
27499 }
27500
27501
27502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27503   void * jresult ;
27504   Dali::FrameBuffer *arg1 = 0 ;
27505   Dali::FrameBuffer *result = 0 ;
27506
27507   arg1 = (Dali::FrameBuffer *)jarg1;
27508   if (!arg1) {
27509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27510     return 0;
27511   }
27512   {
27513     try {
27514       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27515     } catch (std::out_of_range& e) {
27516       {
27517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27518       };
27519     } catch (std::exception& e) {
27520       {
27521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27522       };
27523     } catch (Dali::DaliException e) {
27524       {
27525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27526       };
27527     } catch (...) {
27528       {
27529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27530       };
27531     }
27532   }
27533
27534   jresult = (void *)result;
27535   return jresult;
27536 }
27537
27538
27539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27540   void * jresult ;
27541   Dali::BaseHandle arg1 ;
27542   Dali::BaseHandle *argp1 ;
27543   Dali::FrameBuffer result;
27544
27545   argp1 = (Dali::BaseHandle *)jarg1;
27546   if (!argp1) {
27547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27548     return 0;
27549   }
27550   arg1 = *argp1;
27551   {
27552     try {
27553       result = Dali::FrameBuffer::DownCast(arg1);
27554     } catch (std::out_of_range& e) {
27555       {
27556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27557       };
27558     } catch (std::exception& e) {
27559       {
27560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27561       };
27562     } catch (Dali::DaliException e) {
27563       {
27564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27565       };
27566     } catch (...) {
27567       {
27568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27569       };
27570     }
27571   }
27572
27573   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27574   return jresult;
27575 }
27576
27577
27578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27579   void * jresult ;
27580   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27581   Dali::FrameBuffer *arg2 = 0 ;
27582   Dali::FrameBuffer *result = 0 ;
27583
27584   arg1 = (Dali::FrameBuffer *)jarg1;
27585   arg2 = (Dali::FrameBuffer *)jarg2;
27586   if (!arg2) {
27587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27588     return 0;
27589   }
27590   {
27591     try {
27592       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27593     } catch (std::out_of_range& e) {
27594       {
27595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27596       };
27597     } catch (std::exception& e) {
27598       {
27599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27600       };
27601     } catch (Dali::DaliException e) {
27602       {
27603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27604       };
27605     } catch (...) {
27606       {
27607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27608       };
27609     }
27610   }
27611
27612   jresult = (void *)result;
27613   return jresult;
27614 }
27615
27616
27617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27618   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27619   Dali::Texture *arg2 = 0 ;
27620
27621   arg1 = (Dali::FrameBuffer *)jarg1;
27622   arg2 = (Dali::Texture *)jarg2;
27623   if (!arg2) {
27624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27625     return ;
27626   }
27627   {
27628     try {
27629       (arg1)->AttachColorTexture(*arg2);
27630     } catch (std::out_of_range& e) {
27631       {
27632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27633       };
27634     } catch (std::exception& e) {
27635       {
27636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27637       };
27638     } catch (Dali::DaliException e) {
27639       {
27640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27641       };
27642     } catch (...) {
27643       {
27644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27645       };
27646     }
27647   }
27648
27649 }
27650
27651
27652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27653   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27654   Dali::Texture *arg2 = 0 ;
27655   unsigned int arg3 ;
27656   unsigned int arg4 ;
27657
27658   arg1 = (Dali::FrameBuffer *)jarg1;
27659   arg2 = (Dali::Texture *)jarg2;
27660   if (!arg2) {
27661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27662     return ;
27663   }
27664   arg3 = (unsigned int)jarg3;
27665   arg4 = (unsigned int)jarg4;
27666   {
27667     try {
27668       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27669     } catch (std::out_of_range& e) {
27670       {
27671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27672       };
27673     } catch (std::exception& e) {
27674       {
27675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27676       };
27677     } catch (Dali::DaliException e) {
27678       {
27679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27680       };
27681     } catch (...) {
27682       {
27683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27684       };
27685     }
27686   }
27687
27688 }
27689
27690
27691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27692   void * jresult ;
27693   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27694   Dali::Texture result;
27695
27696   arg1 = (Dali::FrameBuffer *)jarg1;
27697   {
27698     try {
27699       result = (arg1)->GetColorTexture();
27700     } catch (std::out_of_range& e) {
27701       {
27702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27703       };
27704     } catch (std::exception& e) {
27705       {
27706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27707       };
27708     } catch (Dali::DaliException e) {
27709       {
27710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27711       };
27712     } catch (...) {
27713       {
27714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27715       };
27716     }
27717   }
27718
27719   jresult = new Dali::Texture((const Dali::Texture &)result);
27720   return jresult;
27721 }
27722
27723
27724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27725   void * jresult ;
27726   Dali::RenderTaskList *result = 0 ;
27727
27728   {
27729     try {
27730       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27731     } catch (std::out_of_range& e) {
27732       {
27733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27734       };
27735     } catch (std::exception& e) {
27736       {
27737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27738       };
27739     } catch (Dali::DaliException e) {
27740       {
27741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27742       };
27743     } catch (...) {
27744       {
27745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27746       };
27747     }
27748   }
27749
27750   jresult = (void *)result;
27751   return jresult;
27752 }
27753
27754
27755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27756   void * jresult ;
27757   Dali::BaseHandle arg1 ;
27758   Dali::BaseHandle *argp1 ;
27759   Dali::RenderTaskList result;
27760
27761   argp1 = (Dali::BaseHandle *)jarg1;
27762   if (!argp1) {
27763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27764     return 0;
27765   }
27766   arg1 = *argp1;
27767   {
27768     try {
27769       result = Dali::RenderTaskList::DownCast(arg1);
27770     } catch (std::out_of_range& e) {
27771       {
27772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27773       };
27774     } catch (std::exception& e) {
27775       {
27776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27777       };
27778     } catch (Dali::DaliException e) {
27779       {
27780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27781       };
27782     } catch (...) {
27783       {
27784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27785       };
27786     }
27787   }
27788
27789   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27790   return jresult;
27791 }
27792
27793
27794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27795   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27796
27797   arg1 = (Dali::RenderTaskList *)jarg1;
27798   {
27799     try {
27800       delete arg1;
27801     } catch (std::out_of_range& e) {
27802       {
27803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27804       };
27805     } catch (std::exception& e) {
27806       {
27807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27808       };
27809     } catch (Dali::DaliException e) {
27810       {
27811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27812       };
27813     } catch (...) {
27814       {
27815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27816       };
27817     }
27818   }
27819
27820 }
27821
27822
27823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27824   void * jresult ;
27825   Dali::RenderTaskList *arg1 = 0 ;
27826   Dali::RenderTaskList *result = 0 ;
27827
27828   arg1 = (Dali::RenderTaskList *)jarg1;
27829   if (!arg1) {
27830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27831     return 0;
27832   }
27833   {
27834     try {
27835       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27836     } catch (std::out_of_range& e) {
27837       {
27838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27839       };
27840     } catch (std::exception& e) {
27841       {
27842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27843       };
27844     } catch (Dali::DaliException e) {
27845       {
27846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27847       };
27848     } catch (...) {
27849       {
27850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27851       };
27852     }
27853   }
27854
27855   jresult = (void *)result;
27856   return jresult;
27857 }
27858
27859
27860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27861   void * jresult ;
27862   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27863   Dali::RenderTaskList *arg2 = 0 ;
27864   Dali::RenderTaskList *result = 0 ;
27865
27866   arg1 = (Dali::RenderTaskList *)jarg1;
27867   arg2 = (Dali::RenderTaskList *)jarg2;
27868   if (!arg2) {
27869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27870     return 0;
27871   }
27872   {
27873     try {
27874       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27875     } catch (std::out_of_range& e) {
27876       {
27877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27878       };
27879     } catch (std::exception& e) {
27880       {
27881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27882       };
27883     } catch (Dali::DaliException e) {
27884       {
27885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27886       };
27887     } catch (...) {
27888       {
27889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27890       };
27891     }
27892   }
27893
27894   jresult = (void *)result;
27895   return jresult;
27896 }
27897
27898
27899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27900   void * jresult ;
27901   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27902   Dali::RenderTask result;
27903
27904   arg1 = (Dali::RenderTaskList *)jarg1;
27905   {
27906     try {
27907       result = (arg1)->CreateTask();
27908     } catch (std::out_of_range& e) {
27909       {
27910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27911       };
27912     } catch (std::exception& e) {
27913       {
27914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27915       };
27916     } catch (Dali::DaliException e) {
27917       {
27918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27919       };
27920     } catch (...) {
27921       {
27922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27923       };
27924     }
27925   }
27926
27927   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27928   return jresult;
27929 }
27930
27931
27932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27933   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27934   Dali::RenderTask arg2 ;
27935   Dali::RenderTask *argp2 ;
27936
27937   arg1 = (Dali::RenderTaskList *)jarg1;
27938   argp2 = (Dali::RenderTask *)jarg2;
27939   if (!argp2) {
27940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27941     return ;
27942   }
27943   arg2 = *argp2;
27944   {
27945     try {
27946       (arg1)->RemoveTask(arg2);
27947     } catch (std::out_of_range& e) {
27948       {
27949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27950       };
27951     } catch (std::exception& e) {
27952       {
27953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27954       };
27955     } catch (Dali::DaliException e) {
27956       {
27957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27958       };
27959     } catch (...) {
27960       {
27961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27962       };
27963     }
27964   }
27965
27966 }
27967
27968
27969 //// ===============================================end part 1 =================
27970
27971 //// ========================= part 2 ===============================
27972
27973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27974   unsigned int jresult ;
27975   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27976   unsigned int result;
27977
27978   arg1 = (Dali::RenderTaskList *)jarg1;
27979   {
27980     try {
27981       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27982     } catch (std::out_of_range& e) {
27983       {
27984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27985       };
27986     } catch (std::exception& e) {
27987       {
27988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27989       };
27990     } catch (Dali::DaliException e) {
27991       {
27992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27993       };
27994     } catch (...) {
27995       {
27996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27997       };
27998     }
27999   }
28000
28001   jresult = result;
28002   return jresult;
28003 }
28004
28005
28006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
28007   void * jresult ;
28008   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
28009   unsigned int arg2 ;
28010   Dali::RenderTask result;
28011
28012   arg1 = (Dali::RenderTaskList *)jarg1;
28013   arg2 = (unsigned int)jarg2;
28014   {
28015     try {
28016       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
28017     } catch (std::out_of_range& e) {
28018       {
28019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28020       };
28021     } catch (std::exception& e) {
28022       {
28023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28024       };
28025     } catch (Dali::DaliException e) {
28026       {
28027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28028       };
28029     } catch (...) {
28030       {
28031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28032       };
28033     }
28034   }
28035
28036   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28037   return jresult;
28038 }
28039
28040
28041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
28042   int jresult ;
28043   int result;
28044
28045   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
28046   jresult = (int)result;
28047   return jresult;
28048 }
28049
28050
28051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
28052   int jresult ;
28053   int result;
28054
28055   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
28056   jresult = (int)result;
28057   return jresult;
28058 }
28059
28060
28061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28062   int jresult ;
28063   int result;
28064
28065   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28066   jresult = (int)result;
28067   return jresult;
28068 }
28069
28070
28071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28072   int jresult ;
28073   int result;
28074
28075   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28076   jresult = (int)result;
28077   return jresult;
28078 }
28079
28080
28081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28082   void * jresult ;
28083   Dali::RenderTask::Property *result = 0 ;
28084
28085   {
28086     try {
28087       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28088     } catch (std::out_of_range& e) {
28089       {
28090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28091       };
28092     } catch (std::exception& e) {
28093       {
28094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28095       };
28096     } catch (Dali::DaliException e) {
28097       {
28098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28099       };
28100     } catch (...) {
28101       {
28102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28103       };
28104     }
28105   }
28106
28107   jresult = (void *)result;
28108   return jresult;
28109 }
28110
28111
28112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28113   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28114
28115   arg1 = (Dali::RenderTask::Property *)jarg1;
28116   {
28117     try {
28118       delete arg1;
28119     } catch (std::out_of_range& e) {
28120       {
28121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28122       };
28123     } catch (std::exception& e) {
28124       {
28125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28126       };
28127     } catch (Dali::DaliException e) {
28128       {
28129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28130       };
28131     } catch (...) {
28132       {
28133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28134       };
28135     }
28136   }
28137
28138 }
28139
28140
28141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28142   void * jresult ;
28143   bool (*result)(Dali::Vector2 &) = 0 ;
28144
28145   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28146   jresult = (void *)result;
28147   return jresult;
28148 }
28149
28150
28151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28152   void * jresult ;
28153   bool (*result)(Dali::Vector2 &) = 0 ;
28154
28155   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28156   jresult = (void *)result;
28157   return jresult;
28158 }
28159
28160
28161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28162   unsigned int jresult ;
28163   bool result;
28164
28165   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28166   jresult = result;
28167   return jresult;
28168 }
28169
28170
28171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28172   unsigned int jresult ;
28173   bool result;
28174
28175   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28176   jresult = result;
28177   return jresult;
28178 }
28179
28180
28181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28182   void * jresult ;
28183   Dali::Vector4 *result = 0 ;
28184
28185   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28186   jresult = (void *)result;
28187   return jresult;
28188 }
28189
28190
28191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28192   unsigned int jresult ;
28193   bool result;
28194
28195   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28196   jresult = result;
28197   return jresult;
28198 }
28199
28200
28201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28202   unsigned int jresult ;
28203   bool result;
28204
28205   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28206   jresult = result;
28207   return jresult;
28208 }
28209
28210
28211 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28212   unsigned int jresult ;
28213   unsigned int result;
28214
28215   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28216   jresult = result;
28217   return jresult;
28218 }
28219
28220
28221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28222   void * jresult ;
28223   Dali::RenderTask *result = 0 ;
28224
28225   {
28226     try {
28227       result = (Dali::RenderTask *)new Dali::RenderTask();
28228     } catch (std::out_of_range& e) {
28229       {
28230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28231       };
28232     } catch (std::exception& e) {
28233       {
28234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28235       };
28236     } catch (Dali::DaliException e) {
28237       {
28238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28239       };
28240     } catch (...) {
28241       {
28242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28243       };
28244     }
28245   }
28246
28247   jresult = (void *)result;
28248   return jresult;
28249 }
28250
28251
28252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28253   void * jresult ;
28254   Dali::BaseHandle arg1 ;
28255   Dali::BaseHandle *argp1 ;
28256   Dali::RenderTask result;
28257
28258   argp1 = (Dali::BaseHandle *)jarg1;
28259   if (!argp1) {
28260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28261     return 0;
28262   }
28263   arg1 = *argp1;
28264   {
28265     try {
28266       result = Dali::RenderTask::DownCast(arg1);
28267     } catch (std::out_of_range& e) {
28268       {
28269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28270       };
28271     } catch (std::exception& e) {
28272       {
28273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28274       };
28275     } catch (Dali::DaliException e) {
28276       {
28277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28278       };
28279     } catch (...) {
28280       {
28281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28282       };
28283     }
28284   }
28285
28286   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28287   return jresult;
28288 }
28289
28290
28291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28292   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28293
28294   arg1 = (Dali::RenderTask *)jarg1;
28295   {
28296     try {
28297       delete arg1;
28298     } catch (std::out_of_range& e) {
28299       {
28300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28301       };
28302     } catch (std::exception& e) {
28303       {
28304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28305       };
28306     } catch (Dali::DaliException e) {
28307       {
28308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28309       };
28310     } catch (...) {
28311       {
28312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28313       };
28314     }
28315   }
28316
28317 }
28318
28319
28320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28321   void * jresult ;
28322   Dali::RenderTask *arg1 = 0 ;
28323   Dali::RenderTask *result = 0 ;
28324
28325   arg1 = (Dali::RenderTask *)jarg1;
28326   if (!arg1) {
28327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28328     return 0;
28329   }
28330   {
28331     try {
28332       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28333     } catch (std::out_of_range& e) {
28334       {
28335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28336       };
28337     } catch (std::exception& e) {
28338       {
28339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28340       };
28341     } catch (Dali::DaliException e) {
28342       {
28343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28344       };
28345     } catch (...) {
28346       {
28347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28348       };
28349     }
28350   }
28351
28352   jresult = (void *)result;
28353   return jresult;
28354 }
28355
28356
28357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28358   void * jresult ;
28359   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28360   Dali::RenderTask *arg2 = 0 ;
28361   Dali::RenderTask *result = 0 ;
28362
28363   arg1 = (Dali::RenderTask *)jarg1;
28364   arg2 = (Dali::RenderTask *)jarg2;
28365   if (!arg2) {
28366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28367     return 0;
28368   }
28369   {
28370     try {
28371       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28372     } catch (std::out_of_range& e) {
28373       {
28374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28375       };
28376     } catch (std::exception& e) {
28377       {
28378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28379       };
28380     } catch (Dali::DaliException e) {
28381       {
28382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28383       };
28384     } catch (...) {
28385       {
28386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28387       };
28388     }
28389   }
28390
28391   jresult = (void *)result;
28392   return jresult;
28393 }
28394
28395
28396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28397   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28398   Dali::Actor arg2 ;
28399   Dali::Actor *argp2 ;
28400
28401   arg1 = (Dali::RenderTask *)jarg1;
28402   argp2 = (Dali::Actor *)jarg2;
28403   if (!argp2) {
28404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28405     return ;
28406   }
28407   arg2 = *argp2;
28408   {
28409     try {
28410       (arg1)->SetSourceActor(arg2);
28411     } catch (std::out_of_range& e) {
28412       {
28413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28414       };
28415     } catch (std::exception& e) {
28416       {
28417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28418       };
28419     } catch (Dali::DaliException e) {
28420       {
28421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28422       };
28423     } catch (...) {
28424       {
28425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28426       };
28427     }
28428   }
28429
28430 }
28431
28432
28433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28434   void * jresult ;
28435   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28436   Dali::Actor result;
28437
28438   arg1 = (Dali::RenderTask *)jarg1;
28439   {
28440     try {
28441       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28442     } catch (std::out_of_range& e) {
28443       {
28444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28445       };
28446     } catch (std::exception& e) {
28447       {
28448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28449       };
28450     } catch (Dali::DaliException e) {
28451       {
28452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28453       };
28454     } catch (...) {
28455       {
28456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28457       };
28458     }
28459   }
28460
28461   jresult = new Dali::Actor((const Dali::Actor &)result);
28462   return jresult;
28463 }
28464
28465
28466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28467   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28468   bool arg2 ;
28469
28470   arg1 = (Dali::RenderTask *)jarg1;
28471   arg2 = jarg2 ? true : false;
28472   {
28473     try {
28474       (arg1)->SetExclusive(arg2);
28475     } catch (std::out_of_range& e) {
28476       {
28477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28478       };
28479     } catch (std::exception& e) {
28480       {
28481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28482       };
28483     } catch (Dali::DaliException e) {
28484       {
28485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28486       };
28487     } catch (...) {
28488       {
28489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28490       };
28491     }
28492   }
28493
28494 }
28495
28496
28497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28498   unsigned int jresult ;
28499   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28500   bool result;
28501
28502   arg1 = (Dali::RenderTask *)jarg1;
28503   {
28504     try {
28505       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28506     } catch (std::out_of_range& e) {
28507       {
28508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28509       };
28510     } catch (std::exception& e) {
28511       {
28512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28513       };
28514     } catch (Dali::DaliException e) {
28515       {
28516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28517       };
28518     } catch (...) {
28519       {
28520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28521       };
28522     }
28523   }
28524
28525   jresult = result;
28526   return jresult;
28527 }
28528
28529
28530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28531   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28532   bool arg2 ;
28533
28534   arg1 = (Dali::RenderTask *)jarg1;
28535   arg2 = jarg2 ? true : false;
28536   {
28537     try {
28538       (arg1)->SetInputEnabled(arg2);
28539     } catch (std::out_of_range& e) {
28540       {
28541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28542       };
28543     } catch (std::exception& e) {
28544       {
28545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28546       };
28547     } catch (Dali::DaliException e) {
28548       {
28549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28550       };
28551     } catch (...) {
28552       {
28553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28554       };
28555     }
28556   }
28557
28558 }
28559
28560
28561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28562   unsigned int jresult ;
28563   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28564   bool result;
28565
28566   arg1 = (Dali::RenderTask *)jarg1;
28567   {
28568     try {
28569       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28570     } catch (std::out_of_range& e) {
28571       {
28572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28573       };
28574     } catch (std::exception& e) {
28575       {
28576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28577       };
28578     } catch (Dali::DaliException e) {
28579       {
28580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28581       };
28582     } catch (...) {
28583       {
28584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28585       };
28586     }
28587   }
28588
28589   jresult = result;
28590   return jresult;
28591 }
28592
28593
28594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28595   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28596   Dali::CameraActor arg2 ;
28597   Dali::CameraActor *argp2 ;
28598
28599   arg1 = (Dali::RenderTask *)jarg1;
28600   argp2 = (Dali::CameraActor *)jarg2;
28601   if (!argp2) {
28602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28603     return ;
28604   }
28605   arg2 = *argp2;
28606   {
28607     try {
28608       (arg1)->SetCameraActor(arg2);
28609     } catch (std::out_of_range& e) {
28610       {
28611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28612       };
28613     } catch (std::exception& e) {
28614       {
28615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28616       };
28617     } catch (Dali::DaliException e) {
28618       {
28619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28620       };
28621     } catch (...) {
28622       {
28623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28624       };
28625     }
28626   }
28627
28628 }
28629
28630
28631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28632   void * jresult ;
28633   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28634   Dali::CameraActor result;
28635
28636   arg1 = (Dali::RenderTask *)jarg1;
28637   {
28638     try {
28639       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28640     } catch (std::out_of_range& e) {
28641       {
28642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28643       };
28644     } catch (std::exception& e) {
28645       {
28646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28647       };
28648     } catch (Dali::DaliException e) {
28649       {
28650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28651       };
28652     } catch (...) {
28653       {
28654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28655       };
28656     }
28657   }
28658
28659   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28660   return jresult;
28661 }
28662
28663
28664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28665   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28666   Dali::FrameBufferImage arg2 ;
28667   Dali::FrameBufferImage *argp2 ;
28668
28669   arg1 = (Dali::RenderTask *)jarg1;
28670   argp2 = (Dali::FrameBufferImage *)jarg2;
28671   if (!argp2) {
28672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28673     return ;
28674   }
28675   arg2 = *argp2;
28676   {
28677     try {
28678       (arg1)->SetTargetFrameBuffer(arg2);
28679     } catch (std::out_of_range& e) {
28680       {
28681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28682       };
28683     } catch (std::exception& e) {
28684       {
28685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28686       };
28687     } catch (Dali::DaliException e) {
28688       {
28689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28690       };
28691     } catch (...) {
28692       {
28693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28694       };
28695     }
28696   }
28697
28698 }
28699
28700
28701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28702   void * jresult ;
28703   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28704   Dali::FrameBufferImage result;
28705
28706   arg1 = (Dali::RenderTask *)jarg1;
28707   {
28708     try {
28709       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28710     } catch (std::out_of_range& e) {
28711       {
28712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28713       };
28714     } catch (std::exception& e) {
28715       {
28716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28717       };
28718     } catch (Dali::DaliException e) {
28719       {
28720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28721       };
28722     } catch (...) {
28723       {
28724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28725       };
28726     }
28727   }
28728
28729   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28730   return jresult;
28731 }
28732
28733
28734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28735   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28736   Dali::FrameBuffer arg2 ;
28737   Dali::FrameBuffer *argp2 ;
28738
28739   arg1 = (Dali::RenderTask *)jarg1;
28740   argp2 = (Dali::FrameBuffer *)jarg2;
28741   if (!argp2) {
28742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28743     return ;
28744   }
28745   arg2 = *argp2;
28746   {
28747     try {
28748       (arg1)->SetFrameBuffer(arg2);
28749     } catch (std::out_of_range& e) {
28750       {
28751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28752       };
28753     } catch (std::exception& e) {
28754       {
28755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28756       };
28757     } catch (Dali::DaliException e) {
28758       {
28759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28760       };
28761     } catch (...) {
28762       {
28763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28764       };
28765     }
28766   }
28767
28768 }
28769
28770
28771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28772   void * jresult ;
28773   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28774   Dali::FrameBuffer result;
28775
28776   arg1 = (Dali::RenderTask *)jarg1;
28777   {
28778     try {
28779       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28780     } catch (std::out_of_range& e) {
28781       {
28782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28783       };
28784     } catch (std::exception& e) {
28785       {
28786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28787       };
28788     } catch (Dali::DaliException e) {
28789       {
28790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28791       };
28792     } catch (...) {
28793       {
28794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28795       };
28796     }
28797   }
28798
28799   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28800   return jresult;
28801 }
28802
28803
28804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28805   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28806   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28807
28808   arg1 = (Dali::RenderTask *)jarg1;
28809   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28810   {
28811     try {
28812       (arg1)->SetScreenToFrameBufferFunction(arg2);
28813     } catch (std::out_of_range& e) {
28814       {
28815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28816       };
28817     } catch (std::exception& e) {
28818       {
28819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28820       };
28821     } catch (Dali::DaliException e) {
28822       {
28823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28824       };
28825     } catch (...) {
28826       {
28827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28828       };
28829     }
28830   }
28831
28832 }
28833
28834
28835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28836   void * jresult ;
28837   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28838   Dali::RenderTask::ScreenToFrameBufferFunction result;
28839
28840   arg1 = (Dali::RenderTask *)jarg1;
28841   {
28842     try {
28843       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28844     } catch (std::out_of_range& e) {
28845       {
28846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28847       };
28848     } catch (std::exception& e) {
28849       {
28850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28851       };
28852     } catch (Dali::DaliException e) {
28853       {
28854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28855       };
28856     } catch (...) {
28857       {
28858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28859       };
28860     }
28861   }
28862
28863   jresult = (void *)result;
28864   return jresult;
28865 }
28866
28867
28868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28869   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28870   Dali::Actor arg2 ;
28871   Dali::Actor *argp2 ;
28872
28873   arg1 = (Dali::RenderTask *)jarg1;
28874   argp2 = (Dali::Actor *)jarg2;
28875   if (!argp2) {
28876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28877     return ;
28878   }
28879   arg2 = *argp2;
28880   {
28881     try {
28882       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28883     } catch (std::out_of_range& e) {
28884       {
28885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28886       };
28887     } catch (std::exception& e) {
28888       {
28889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28890       };
28891     } catch (Dali::DaliException e) {
28892       {
28893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28894       };
28895     } catch (...) {
28896       {
28897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28898       };
28899     }
28900   }
28901
28902 }
28903
28904
28905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28906   void * jresult ;
28907   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28908   Dali::Actor result;
28909
28910   arg1 = (Dali::RenderTask *)jarg1;
28911   {
28912     try {
28913       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28914     } catch (std::out_of_range& e) {
28915       {
28916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28917       };
28918     } catch (std::exception& e) {
28919       {
28920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28921       };
28922     } catch (Dali::DaliException e) {
28923       {
28924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28925       };
28926     } catch (...) {
28927       {
28928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28929       };
28930     }
28931   }
28932
28933   jresult = new Dali::Actor((const Dali::Actor &)result);
28934   return jresult;
28935 }
28936
28937
28938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28939   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28940   Dali::Vector2 arg2 ;
28941   Dali::Vector2 *argp2 ;
28942
28943   arg1 = (Dali::RenderTask *)jarg1;
28944   argp2 = (Dali::Vector2 *)jarg2;
28945   if (!argp2) {
28946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28947     return ;
28948   }
28949   arg2 = *argp2;
28950   {
28951     try {
28952       (arg1)->SetViewportPosition(arg2);
28953     } catch (std::out_of_range& e) {
28954       {
28955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28956       };
28957     } catch (std::exception& e) {
28958       {
28959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28960       };
28961     } catch (Dali::DaliException e) {
28962       {
28963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28964       };
28965     } catch (...) {
28966       {
28967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28968       };
28969     }
28970   }
28971
28972 }
28973
28974
28975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28976   void * jresult ;
28977   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28978   Dali::Vector2 result;
28979
28980   arg1 = (Dali::RenderTask *)jarg1;
28981   {
28982     try {
28983       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28984     } catch (std::out_of_range& e) {
28985       {
28986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28987       };
28988     } catch (std::exception& e) {
28989       {
28990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28991       };
28992     } catch (Dali::DaliException e) {
28993       {
28994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28995       };
28996     } catch (...) {
28997       {
28998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28999       };
29000     }
29001   }
29002
29003   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29004   return jresult;
29005 }
29006
29007
29008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
29009   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29010   Dali::Vector2 arg2 ;
29011   Dali::Vector2 *argp2 ;
29012
29013   arg1 = (Dali::RenderTask *)jarg1;
29014   argp2 = (Dali::Vector2 *)jarg2;
29015   if (!argp2) {
29016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
29017     return ;
29018   }
29019   arg2 = *argp2;
29020   {
29021     try {
29022       (arg1)->SetViewportSize(arg2);
29023     } catch (std::out_of_range& e) {
29024       {
29025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29026       };
29027     } catch (std::exception& e) {
29028       {
29029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29030       };
29031     } catch (Dali::DaliException e) {
29032       {
29033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29034       };
29035     } catch (...) {
29036       {
29037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29038       };
29039     }
29040   }
29041
29042 }
29043
29044
29045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
29046   void * jresult ;
29047   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29048   Dali::Vector2 result;
29049
29050   arg1 = (Dali::RenderTask *)jarg1;
29051   {
29052     try {
29053       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
29054     } catch (std::out_of_range& e) {
29055       {
29056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29057       };
29058     } catch (std::exception& e) {
29059       {
29060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29061       };
29062     } catch (Dali::DaliException e) {
29063       {
29064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29065       };
29066     } catch (...) {
29067       {
29068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29069       };
29070     }
29071   }
29072
29073   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29074   return jresult;
29075 }
29076
29077
29078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29079   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29080   Dali::Viewport arg2 ;
29081   Dali::Viewport *argp2 ;
29082
29083   arg1 = (Dali::RenderTask *)jarg1;
29084   argp2 = (Dali::Viewport *)jarg2;
29085   if (!argp2) {
29086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29087     return ;
29088   }
29089   arg2 = *argp2;
29090   {
29091     try {
29092       (arg1)->SetViewport(arg2);
29093     } catch (std::out_of_range& e) {
29094       {
29095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29096       };
29097     } catch (std::exception& e) {
29098       {
29099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29100       };
29101     } catch (Dali::DaliException e) {
29102       {
29103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29104       };
29105     } catch (...) {
29106       {
29107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29108       };
29109     }
29110   }
29111
29112 }
29113
29114
29115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29116   void * jresult ;
29117   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29118   Dali::Viewport result;
29119
29120   arg1 = (Dali::RenderTask *)jarg1;
29121   {
29122     try {
29123       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29124     } catch (std::out_of_range& e) {
29125       {
29126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29127       };
29128     } catch (std::exception& e) {
29129       {
29130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29131       };
29132     } catch (Dali::DaliException e) {
29133       {
29134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29135       };
29136     } catch (...) {
29137       {
29138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29139       };
29140     }
29141   }
29142
29143   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29144   return jresult;
29145 }
29146
29147
29148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29149   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29150   Dali::Vector4 *arg2 = 0 ;
29151
29152   arg1 = (Dali::RenderTask *)jarg1;
29153   arg2 = (Dali::Vector4 *)jarg2;
29154   if (!arg2) {
29155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29156     return ;
29157   }
29158   {
29159     try {
29160       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29161     } catch (std::out_of_range& e) {
29162       {
29163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29164       };
29165     } catch (std::exception& e) {
29166       {
29167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29168       };
29169     } catch (Dali::DaliException e) {
29170       {
29171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29172       };
29173     } catch (...) {
29174       {
29175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29176       };
29177     }
29178   }
29179
29180 }
29181
29182
29183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29184   void * jresult ;
29185   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29186   Dali::Vector4 result;
29187
29188   arg1 = (Dali::RenderTask *)jarg1;
29189   {
29190     try {
29191       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29192     } catch (std::out_of_range& e) {
29193       {
29194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29195       };
29196     } catch (std::exception& e) {
29197       {
29198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29199       };
29200     } catch (Dali::DaliException e) {
29201       {
29202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29203       };
29204     } catch (...) {
29205       {
29206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29207       };
29208     }
29209   }
29210
29211   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29212   return jresult;
29213 }
29214
29215
29216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29217   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29218   bool arg2 ;
29219
29220   arg1 = (Dali::RenderTask *)jarg1;
29221   arg2 = jarg2 ? true : false;
29222   {
29223     try {
29224       (arg1)->SetClearEnabled(arg2);
29225     } catch (std::out_of_range& e) {
29226       {
29227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29228       };
29229     } catch (std::exception& e) {
29230       {
29231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29232       };
29233     } catch (Dali::DaliException e) {
29234       {
29235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29236       };
29237     } catch (...) {
29238       {
29239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29240       };
29241     }
29242   }
29243
29244 }
29245
29246
29247 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29248   unsigned int jresult ;
29249   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29250   bool result;
29251
29252   arg1 = (Dali::RenderTask *)jarg1;
29253   {
29254     try {
29255       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29256     } catch (std::out_of_range& e) {
29257       {
29258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29259       };
29260     } catch (std::exception& e) {
29261       {
29262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29263       };
29264     } catch (Dali::DaliException e) {
29265       {
29266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29267       };
29268     } catch (...) {
29269       {
29270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29271       };
29272     }
29273   }
29274
29275   jresult = result;
29276   return jresult;
29277 }
29278
29279
29280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29281   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29282   bool arg2 ;
29283
29284   arg1 = (Dali::RenderTask *)jarg1;
29285   arg2 = jarg2 ? true : false;
29286   {
29287     try {
29288       (arg1)->SetCullMode(arg2);
29289     } catch (std::out_of_range& e) {
29290       {
29291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29292       };
29293     } catch (std::exception& e) {
29294       {
29295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29296       };
29297     } catch (Dali::DaliException e) {
29298       {
29299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29300       };
29301     } catch (...) {
29302       {
29303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29304       };
29305     }
29306   }
29307
29308 }
29309
29310
29311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29312   unsigned int jresult ;
29313   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29314   bool result;
29315
29316   arg1 = (Dali::RenderTask *)jarg1;
29317   {
29318     try {
29319       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29320     } catch (std::out_of_range& e) {
29321       {
29322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29323       };
29324     } catch (std::exception& e) {
29325       {
29326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29327       };
29328     } catch (Dali::DaliException e) {
29329       {
29330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29331       };
29332     } catch (...) {
29333       {
29334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29335       };
29336     }
29337   }
29338
29339   jresult = result;
29340   return jresult;
29341 }
29342
29343
29344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29345   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29346   unsigned int arg2 ;
29347
29348   arg1 = (Dali::RenderTask *)jarg1;
29349   arg2 = (unsigned int)jarg2;
29350   {
29351     try {
29352       (arg1)->SetRefreshRate(arg2);
29353     } catch (std::out_of_range& e) {
29354       {
29355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29356       };
29357     } catch (std::exception& e) {
29358       {
29359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29360       };
29361     } catch (Dali::DaliException e) {
29362       {
29363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29364       };
29365     } catch (...) {
29366       {
29367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29368       };
29369     }
29370   }
29371
29372 }
29373
29374
29375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29376   unsigned int jresult ;
29377   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29378   unsigned int result;
29379
29380   arg1 = (Dali::RenderTask *)jarg1;
29381   {
29382     try {
29383       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29384     } catch (std::out_of_range& e) {
29385       {
29386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29387       };
29388     } catch (std::exception& e) {
29389       {
29390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29391       };
29392     } catch (Dali::DaliException e) {
29393       {
29394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29395       };
29396     } catch (...) {
29397       {
29398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29399       };
29400     }
29401   }
29402
29403   jresult = result;
29404   return jresult;
29405 }
29406
29407
29408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29409   unsigned int jresult ;
29410   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29411   Dali::Vector3 *arg2 = 0 ;
29412   float *arg3 = 0 ;
29413   float *arg4 = 0 ;
29414   bool result;
29415
29416   arg1 = (Dali::RenderTask *)jarg1;
29417   arg2 = (Dali::Vector3 *)jarg2;
29418   if (!arg2) {
29419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29420     return 0;
29421   }
29422   arg3 = (float *)jarg3;
29423   arg4 = (float *)jarg4;
29424   {
29425     try {
29426       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29427     } catch (std::out_of_range& e) {
29428       {
29429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29430       };
29431     } catch (std::exception& e) {
29432       {
29433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29434       };
29435     } catch (Dali::DaliException e) {
29436       {
29437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29438       };
29439     } catch (...) {
29440       {
29441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29442       };
29443     }
29444   }
29445
29446   jresult = result;
29447   return jresult;
29448 }
29449
29450
29451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29452   unsigned int jresult ;
29453   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29454   Dali::Actor arg2 ;
29455   float arg3 ;
29456   float arg4 ;
29457   float *arg5 = 0 ;
29458   float *arg6 = 0 ;
29459   Dali::Actor *argp2 ;
29460   bool result;
29461
29462   arg1 = (Dali::RenderTask *)jarg1;
29463   argp2 = (Dali::Actor *)jarg2;
29464   if (!argp2) {
29465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29466     return 0;
29467   }
29468   arg2 = *argp2;
29469   arg3 = (float)jarg3;
29470   arg4 = (float)jarg4;
29471   arg5 = (float *)jarg5;
29472   arg6 = (float *)jarg6;
29473   {
29474     try {
29475       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29476     } catch (std::out_of_range& e) {
29477       {
29478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29479       };
29480     } catch (std::exception& e) {
29481       {
29482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29483       };
29484     } catch (Dali::DaliException e) {
29485       {
29486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29487       };
29488     } catch (...) {
29489       {
29490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29491       };
29492     }
29493   }
29494
29495   jresult = result;
29496   return jresult;
29497 }
29498
29499
29500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29501   void * jresult ;
29502   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29503   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29504
29505   arg1 = (Dali::RenderTask *)jarg1;
29506   {
29507     try {
29508       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29509     } catch (std::out_of_range& e) {
29510       {
29511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29512       };
29513     } catch (std::exception& e) {
29514       {
29515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29516       };
29517     } catch (Dali::DaliException e) {
29518       {
29519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29520       };
29521     } catch (...) {
29522       {
29523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29524       };
29525     }
29526   }
29527
29528   jresult = (void *)result;
29529   return jresult;
29530 }
29531
29532
29533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29534   void * jresult ;
29535   int arg1 ;
29536   Dali::TouchPoint::State arg2 ;
29537   float arg3 ;
29538   float arg4 ;
29539   Dali::TouchPoint *result = 0 ;
29540
29541   arg1 = (int)jarg1;
29542   arg2 = (Dali::TouchPoint::State)jarg2;
29543   arg3 = (float)jarg3;
29544   arg4 = (float)jarg4;
29545   {
29546     try {
29547       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29548     } catch (std::out_of_range& e) {
29549       {
29550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29551       };
29552     } catch (std::exception& e) {
29553       {
29554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29555       };
29556     } catch (Dali::DaliException e) {
29557       {
29558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29559       };
29560     } catch (...) {
29561       {
29562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29563       };
29564     }
29565   }
29566
29567   jresult = (void *)result;
29568   return jresult;
29569 }
29570
29571
29572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29573   void * jresult ;
29574   int arg1 ;
29575   Dali::TouchPoint::State arg2 ;
29576   float arg3 ;
29577   float arg4 ;
29578   float arg5 ;
29579   float arg6 ;
29580   Dali::TouchPoint *result = 0 ;
29581
29582   arg1 = (int)jarg1;
29583   arg2 = (Dali::TouchPoint::State)jarg2;
29584   arg3 = (float)jarg3;
29585   arg4 = (float)jarg4;
29586   arg5 = (float)jarg5;
29587   arg6 = (float)jarg6;
29588   {
29589     try {
29590       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29591     } catch (std::out_of_range& e) {
29592       {
29593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29594       };
29595     } catch (std::exception& e) {
29596       {
29597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29598       };
29599     } catch (Dali::DaliException e) {
29600       {
29601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29602       };
29603     } catch (...) {
29604       {
29605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29606       };
29607     }
29608   }
29609
29610   jresult = (void *)result;
29611   return jresult;
29612 }
29613
29614
29615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29616   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29617
29618   arg1 = (Dali::TouchPoint *)jarg1;
29619   {
29620     try {
29621       delete arg1;
29622     } catch (std::out_of_range& e) {
29623       {
29624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29625       };
29626     } catch (std::exception& e) {
29627       {
29628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29629       };
29630     } catch (Dali::DaliException e) {
29631       {
29632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29633       };
29634     } catch (...) {
29635       {
29636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29637       };
29638     }
29639   }
29640
29641 }
29642
29643
29644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29645   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29646   int arg2 ;
29647
29648   arg1 = (Dali::TouchPoint *)jarg1;
29649   arg2 = (int)jarg2;
29650   if (arg1) (arg1)->deviceId = arg2;
29651 }
29652
29653
29654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29655   int jresult ;
29656   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29657   int result;
29658
29659   arg1 = (Dali::TouchPoint *)jarg1;
29660   result = (int) ((arg1)->deviceId);
29661   jresult = result;
29662   return jresult;
29663 }
29664
29665
29666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29667   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29668   Dali::TouchPoint::State arg2 ;
29669
29670   arg1 = (Dali::TouchPoint *)jarg1;
29671   arg2 = (Dali::TouchPoint::State)jarg2;
29672   if (arg1) (arg1)->state = arg2;
29673 }
29674
29675
29676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29677   int jresult ;
29678   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29679   Dali::TouchPoint::State result;
29680
29681   arg1 = (Dali::TouchPoint *)jarg1;
29682   result = (Dali::TouchPoint::State) ((arg1)->state);
29683   jresult = (int)result;
29684   return jresult;
29685 }
29686
29687
29688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29689   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29690   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29691
29692   arg1 = (Dali::TouchPoint *)jarg1;
29693   arg2 = (Dali::Actor *)jarg2;
29694   if (arg1) (arg1)->hitActor = *arg2;
29695 }
29696
29697
29698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29699   void * jresult ;
29700   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29701   Dali::Actor *result = 0 ;
29702
29703   arg1 = (Dali::TouchPoint *)jarg1;
29704   result = (Dali::Actor *)& ((arg1)->hitActor);
29705   jresult = (void *)result;
29706   return jresult;
29707 }
29708
29709
29710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29711   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29712   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29713
29714   arg1 = (Dali::TouchPoint *)jarg1;
29715   arg2 = (Dali::Vector2 *)jarg2;
29716   if (arg1) (arg1)->local = *arg2;
29717 }
29718
29719
29720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29721   void * jresult ;
29722   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29723   Dali::Vector2 *result = 0 ;
29724
29725   arg1 = (Dali::TouchPoint *)jarg1;
29726   result = (Dali::Vector2 *)& ((arg1)->local);
29727   jresult = (void *)result;
29728   return jresult;
29729 }
29730
29731
29732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29733   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29734   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29735
29736   arg1 = (Dali::TouchPoint *)jarg1;
29737   arg2 = (Dali::Vector2 *)jarg2;
29738   if (arg1) (arg1)->screen = *arg2;
29739 }
29740
29741
29742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29743   void * jresult ;
29744   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29745   Dali::Vector2 *result = 0 ;
29746
29747   arg1 = (Dali::TouchPoint *)jarg1;
29748   result = (Dali::Vector2 *)& ((arg1)->screen);
29749   jresult = (void *)result;
29750   return jresult;
29751 }
29752
29753
29754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29755   void * jresult ;
29756   Dali::TouchData *result = 0 ;
29757
29758   {
29759     try {
29760       result = (Dali::TouchData *)new Dali::TouchData();
29761     } catch (std::out_of_range& e) {
29762       {
29763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29764       };
29765     } catch (std::exception& e) {
29766       {
29767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29768       };
29769     } catch (Dali::DaliException e) {
29770       {
29771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29772       };
29773     } catch (...) {
29774       {
29775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29776       };
29777     }
29778   }
29779
29780   jresult = (void *)result;
29781   return jresult;
29782 }
29783
29784
29785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29786   void * jresult ;
29787   Dali::TouchData *arg1 = 0 ;
29788   Dali::TouchData *result = 0 ;
29789
29790   arg1 = (Dali::TouchData *)jarg1;
29791   if (!arg1) {
29792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29793     return 0;
29794   }
29795   {
29796     try {
29797       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29798     } catch (std::out_of_range& e) {
29799       {
29800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29801       };
29802     } catch (std::exception& e) {
29803       {
29804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29805       };
29806     } catch (Dali::DaliException e) {
29807       {
29808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29809       };
29810     } catch (...) {
29811       {
29812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29813       };
29814     }
29815   }
29816
29817   jresult = (void *)result;
29818   return jresult;
29819 }
29820
29821
29822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29823   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29824
29825   arg1 = (Dali::TouchData *)jarg1;
29826   {
29827     try {
29828       delete arg1;
29829     } catch (std::out_of_range& e) {
29830       {
29831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29832       };
29833     } catch (std::exception& e) {
29834       {
29835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29836       };
29837     } catch (Dali::DaliException e) {
29838       {
29839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29840       };
29841     } catch (...) {
29842       {
29843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29844       };
29845     }
29846   }
29847
29848 }
29849
29850
29851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29852   void * jresult ;
29853   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29854   Dali::TouchData *arg2 = 0 ;
29855   Dali::TouchData *result = 0 ;
29856
29857   arg1 = (Dali::TouchData *)jarg1;
29858   arg2 = (Dali::TouchData *)jarg2;
29859   if (!arg2) {
29860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29861     return 0;
29862   }
29863   {
29864     try {
29865       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29866     } catch (std::out_of_range& e) {
29867       {
29868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29869       };
29870     } catch (std::exception& e) {
29871       {
29872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29873       };
29874     } catch (Dali::DaliException e) {
29875       {
29876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29877       };
29878     } catch (...) {
29879       {
29880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29881       };
29882     }
29883   }
29884
29885   jresult = (void *)result;
29886   return jresult;
29887 }
29888
29889
29890 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29891   unsigned long jresult ;
29892   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29893   unsigned long result;
29894
29895   arg1 = (Dali::TouchData *)jarg1;
29896   {
29897     try {
29898       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29899     } catch (std::out_of_range& e) {
29900       {
29901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29902       };
29903     } catch (std::exception& e) {
29904       {
29905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29906       };
29907     } catch (Dali::DaliException e) {
29908       {
29909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29910       };
29911     } catch (...) {
29912       {
29913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29914       };
29915     }
29916   }
29917
29918   jresult = (unsigned long)result;
29919   return jresult;
29920 }
29921
29922
29923 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29924   unsigned long jresult ;
29925   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29926   std::size_t result;
29927
29928   arg1 = (Dali::TouchData *)jarg1;
29929   {
29930     try {
29931       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29932     } catch (std::out_of_range& e) {
29933       {
29934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29935       };
29936     } catch (std::exception& e) {
29937       {
29938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29939       };
29940     } catch (Dali::DaliException e) {
29941       {
29942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29943       };
29944     } catch (...) {
29945       {
29946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29947       };
29948     }
29949   }
29950
29951   jresult = (unsigned long)result;
29952   return jresult;
29953 }
29954
29955
29956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29957   int jresult ;
29958   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29959   std::size_t arg2 ;
29960   int32_t result;
29961
29962   arg1 = (Dali::TouchData *)jarg1;
29963   arg2 = (std::size_t)jarg2;
29964   {
29965     try {
29966       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29967     } catch (std::out_of_range& e) {
29968       {
29969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29970       };
29971     } catch (std::exception& e) {
29972       {
29973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29974       };
29975     } catch (Dali::DaliException e) {
29976       {
29977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29978       };
29979     } catch (...) {
29980       {
29981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29982       };
29983     }
29984   }
29985
29986   jresult = result;
29987   return jresult;
29988 }
29989
29990
29991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29992   int jresult ;
29993   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29994   std::size_t arg2 ;
29995   Dali::PointState::Type result;
29996
29997   arg1 = (Dali::TouchData *)jarg1;
29998   arg2 = (std::size_t)jarg2;
29999   {
30000     try {
30001       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
30002     } catch (std::out_of_range& e) {
30003       {
30004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30005       };
30006     } catch (std::exception& e) {
30007       {
30008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30009       };
30010     } catch (Dali::DaliException e) {
30011       {
30012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30013       };
30014     } catch (...) {
30015       {
30016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30017       };
30018     }
30019   }
30020
30021   jresult = (int)result;
30022   return jresult;
30023 }
30024
30025
30026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
30027   void * jresult ;
30028   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30029   std::size_t arg2 ;
30030   Dali::Actor result;
30031
30032   arg1 = (Dali::TouchData *)jarg1;
30033   arg2 = (std::size_t)jarg2;
30034   {
30035     try {
30036       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
30037     } catch (std::out_of_range& e) {
30038       {
30039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30040       };
30041     } catch (std::exception& e) {
30042       {
30043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30044       };
30045     } catch (Dali::DaliException e) {
30046       {
30047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30048       };
30049     } catch (...) {
30050       {
30051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30052       };
30053     }
30054   }
30055
30056   jresult = new Dali::Actor((const Dali::Actor &)result);
30057   return jresult;
30058 }
30059
30060
30061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30062   void * jresult ;
30063   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30064   std::size_t arg2 ;
30065   Dali::Vector2 *result = 0 ;
30066
30067   arg1 = (Dali::TouchData *)jarg1;
30068   arg2 = (std::size_t)jarg2;
30069   {
30070     try {
30071       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30072     } catch (std::out_of_range& e) {
30073       {
30074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30075       };
30076     } catch (std::exception& e) {
30077       {
30078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30079       };
30080     } catch (Dali::DaliException e) {
30081       {
30082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30083       };
30084     } catch (...) {
30085       {
30086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30087       };
30088     }
30089   }
30090
30091   jresult = (void *)result;
30092   return jresult;
30093 }
30094
30095
30096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30097   void * jresult ;
30098   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30099   std::size_t arg2 ;
30100   Dali::Vector2 *result = 0 ;
30101
30102   arg1 = (Dali::TouchData *)jarg1;
30103   arg2 = (std::size_t)jarg2;
30104   {
30105     try {
30106       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30107     } catch (std::out_of_range& e) {
30108       {
30109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30110       };
30111     } catch (std::exception& e) {
30112       {
30113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30114       };
30115     } catch (Dali::DaliException e) {
30116       {
30117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30118       };
30119     } catch (...) {
30120       {
30121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30122       };
30123     }
30124   }
30125
30126   jresult = (void *)result;
30127   return jresult;
30128 }
30129
30130
30131 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30132   float jresult ;
30133   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30134   std::size_t arg2 ;
30135   float result;
30136
30137   arg1 = (Dali::TouchData *)jarg1;
30138   arg2 = (std::size_t)jarg2;
30139   {
30140     try {
30141       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30142     } catch (std::out_of_range& e) {
30143       {
30144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30145       };
30146     } catch (std::exception& e) {
30147       {
30148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30149       };
30150     } catch (Dali::DaliException e) {
30151       {
30152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30153       };
30154     } catch (...) {
30155       {
30156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30157       };
30158     }
30159   }
30160
30161   jresult = result;
30162   return jresult;
30163 }
30164
30165
30166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30167   void * jresult ;
30168   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30169   std::size_t arg2 ;
30170   Dali::Vector2 *result = 0 ;
30171
30172   arg1 = (Dali::TouchData *)jarg1;
30173   arg2 = (std::size_t)jarg2;
30174   {
30175     try {
30176       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30177     } catch (std::out_of_range& e) {
30178       {
30179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30180       };
30181     } catch (std::exception& e) {
30182       {
30183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30184       };
30185     } catch (Dali::DaliException e) {
30186       {
30187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30188       };
30189     } catch (...) {
30190       {
30191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30192       };
30193     }
30194   }
30195
30196   jresult = (void *)result;
30197   return jresult;
30198 }
30199
30200
30201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30202   float jresult ;
30203   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30204   std::size_t arg2 ;
30205   float result;
30206
30207   arg1 = (Dali::TouchData *)jarg1;
30208   arg2 = (std::size_t)jarg2;
30209   {
30210     try {
30211       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30212     } catch (std::out_of_range& e) {
30213       {
30214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30215       };
30216     } catch (std::exception& e) {
30217       {
30218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30219       };
30220     } catch (Dali::DaliException e) {
30221       {
30222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30223       };
30224     } catch (...) {
30225       {
30226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30227       };
30228     }
30229   }
30230
30231   jresult = result;
30232   return jresult;
30233 }
30234
30235
30236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30237   void * jresult ;
30238   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30239   std::size_t arg2 ;
30240   Dali::Degree result;
30241
30242   arg1 = (Dali::TouchData *)jarg1;
30243   arg2 = (std::size_t)jarg2;
30244   {
30245     try {
30246       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30247     } catch (std::out_of_range& e) {
30248       {
30249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30250       };
30251     } catch (std::exception& e) {
30252       {
30253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30254       };
30255     } catch (Dali::DaliException e) {
30256       {
30257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30258       };
30259     } catch (...) {
30260       {
30261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30262       };
30263     }
30264   }
30265
30266   jresult = new Dali::Degree((const Dali::Degree &)result);
30267   return jresult;
30268 }
30269
30270
30271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30272   void * jresult ;
30273   Dali::GestureDetector *result = 0 ;
30274
30275   {
30276     try {
30277       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30278     } catch (std::out_of_range& e) {
30279       {
30280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30281       };
30282     } catch (std::exception& e) {
30283       {
30284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30285       };
30286     } catch (Dali::DaliException e) {
30287       {
30288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30289       };
30290     } catch (...) {
30291       {
30292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30293       };
30294     }
30295   }
30296
30297   jresult = (void *)result;
30298   return jresult;
30299 }
30300
30301
30302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30303   void * jresult ;
30304   Dali::BaseHandle arg1 ;
30305   Dali::BaseHandle *argp1 ;
30306   Dali::GestureDetector result;
30307
30308   argp1 = (Dali::BaseHandle *)jarg1;
30309   if (!argp1) {
30310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30311     return 0;
30312   }
30313   arg1 = *argp1;
30314   {
30315     try {
30316       result = Dali::GestureDetector::DownCast(arg1);
30317     } catch (std::out_of_range& e) {
30318       {
30319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30320       };
30321     } catch (std::exception& e) {
30322       {
30323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30324       };
30325     } catch (Dali::DaliException e) {
30326       {
30327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30328       };
30329     } catch (...) {
30330       {
30331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30332       };
30333     }
30334   }
30335
30336   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30337   return jresult;
30338 }
30339
30340
30341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30342   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30343
30344   arg1 = (Dali::GestureDetector *)jarg1;
30345   {
30346     try {
30347       delete arg1;
30348     } catch (std::out_of_range& e) {
30349       {
30350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30351       };
30352     } catch (std::exception& e) {
30353       {
30354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30355       };
30356     } catch (Dali::DaliException e) {
30357       {
30358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30359       };
30360     } catch (...) {
30361       {
30362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30363       };
30364     }
30365   }
30366
30367 }
30368
30369
30370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30371   void * jresult ;
30372   Dali::GestureDetector *arg1 = 0 ;
30373   Dali::GestureDetector *result = 0 ;
30374
30375   arg1 = (Dali::GestureDetector *)jarg1;
30376   if (!arg1) {
30377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30378     return 0;
30379   }
30380   {
30381     try {
30382       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30383     } catch (std::out_of_range& e) {
30384       {
30385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30386       };
30387     } catch (std::exception& e) {
30388       {
30389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30390       };
30391     } catch (Dali::DaliException e) {
30392       {
30393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30394       };
30395     } catch (...) {
30396       {
30397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30398       };
30399     }
30400   }
30401
30402   jresult = (void *)result;
30403   return jresult;
30404 }
30405
30406
30407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30408   void * jresult ;
30409   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30410   Dali::GestureDetector *arg2 = 0 ;
30411   Dali::GestureDetector *result = 0 ;
30412
30413   arg1 = (Dali::GestureDetector *)jarg1;
30414   arg2 = (Dali::GestureDetector *)jarg2;
30415   if (!arg2) {
30416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30417     return 0;
30418   }
30419   {
30420     try {
30421       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30422     } catch (std::out_of_range& e) {
30423       {
30424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30425       };
30426     } catch (std::exception& e) {
30427       {
30428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30429       };
30430     } catch (Dali::DaliException e) {
30431       {
30432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30433       };
30434     } catch (...) {
30435       {
30436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30437       };
30438     }
30439   }
30440
30441   jresult = (void *)result;
30442   return jresult;
30443 }
30444
30445
30446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30447   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30448   Dali::Actor arg2 ;
30449   Dali::Actor *argp2 ;
30450
30451   arg1 = (Dali::GestureDetector *)jarg1;
30452   argp2 = (Dali::Actor *)jarg2;
30453   if (!argp2) {
30454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30455     return ;
30456   }
30457   arg2 = *argp2;
30458   {
30459     try {
30460       (arg1)->Attach(arg2);
30461     } catch (std::out_of_range& e) {
30462       {
30463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30464       };
30465     } catch (std::exception& e) {
30466       {
30467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30468       };
30469     } catch (Dali::DaliException e) {
30470       {
30471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30472       };
30473     } catch (...) {
30474       {
30475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30476       };
30477     }
30478   }
30479
30480 }
30481
30482
30483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(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)->Detach(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_DetachAll(void * jarg1) {
30521   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30522
30523   arg1 = (Dali::GestureDetector *)jarg1;
30524   {
30525     try {
30526       (arg1)->DetachAll();
30527     } catch (std::out_of_range& e) {
30528       {
30529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30530       };
30531     } catch (std::exception& e) {
30532       {
30533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30534       };
30535     } catch (Dali::DaliException e) {
30536       {
30537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30538       };
30539     } catch (...) {
30540       {
30541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30542       };
30543     }
30544   }
30545
30546 }
30547
30548
30549 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30550   unsigned long jresult ;
30551   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30552   size_t result;
30553
30554   arg1 = (Dali::GestureDetector *)jarg1;
30555   {
30556     try {
30557       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30558     } catch (std::out_of_range& e) {
30559       {
30560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30561       };
30562     } catch (std::exception& e) {
30563       {
30564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30565       };
30566     } catch (Dali::DaliException e) {
30567       {
30568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30569       };
30570     } catch (...) {
30571       {
30572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30573       };
30574     }
30575   }
30576
30577   jresult = (unsigned long)result;
30578   return jresult;
30579 }
30580
30581
30582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30583   void * jresult ;
30584   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30585   size_t arg2 ;
30586   Dali::Actor result;
30587
30588   arg1 = (Dali::GestureDetector *)jarg1;
30589   arg2 = (size_t)jarg2;
30590   {
30591     try {
30592       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30593     } catch (std::out_of_range& e) {
30594       {
30595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30596       };
30597     } catch (std::exception& e) {
30598       {
30599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30600       };
30601     } catch (Dali::DaliException e) {
30602       {
30603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30604       };
30605     } catch (...) {
30606       {
30607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30608       };
30609     }
30610   }
30611
30612   jresult = new Dali::Actor((const Dali::Actor &)result);
30613   return jresult;
30614 }
30615
30616
30617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30618   void * jresult ;
30619   Dali::Gesture *arg1 = 0 ;
30620   Dali::Gesture *result = 0 ;
30621
30622   arg1 = (Dali::Gesture *)jarg1;
30623   if (!arg1) {
30624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30625     return 0;
30626   }
30627   {
30628     try {
30629       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
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 = (void *)result;
30650   return jresult;
30651 }
30652
30653
30654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30655   void * jresult ;
30656   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30657   Dali::Gesture *arg2 = 0 ;
30658   Dali::Gesture *result = 0 ;
30659
30660   arg1 = (Dali::Gesture *)jarg1;
30661   arg2 = (Dali::Gesture *)jarg2;
30662   if (!arg2) {
30663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30664     return 0;
30665   }
30666   {
30667     try {
30668       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30669     } catch (std::out_of_range& e) {
30670       {
30671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30672       };
30673     } catch (std::exception& e) {
30674       {
30675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30676       };
30677     } catch (Dali::DaliException e) {
30678       {
30679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30680       };
30681     } catch (...) {
30682       {
30683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30684       };
30685     }
30686   }
30687
30688   jresult = (void *)result;
30689   return jresult;
30690 }
30691
30692
30693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30694   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30695
30696   arg1 = (Dali::Gesture *)jarg1;
30697   {
30698     try {
30699       delete arg1;
30700     } catch (std::out_of_range& e) {
30701       {
30702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30703       };
30704     } catch (std::exception& e) {
30705       {
30706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30707       };
30708     } catch (Dali::DaliException e) {
30709       {
30710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30711       };
30712     } catch (...) {
30713       {
30714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30715       };
30716     }
30717   }
30718
30719 }
30720
30721
30722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30723   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30724   Dali::Gesture::Type arg2 ;
30725
30726   arg1 = (Dali::Gesture *)jarg1;
30727   arg2 = (Dali::Gesture::Type)jarg2;
30728   if (arg1) (arg1)->type = arg2;
30729 }
30730
30731
30732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30733   int jresult ;
30734   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30735   Dali::Gesture::Type result;
30736
30737   arg1 = (Dali::Gesture *)jarg1;
30738   result = (Dali::Gesture::Type) ((arg1)->type);
30739   jresult = (int)result;
30740   return jresult;
30741 }
30742
30743
30744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30745   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30746   Dali::Gesture::State arg2 ;
30747
30748   arg1 = (Dali::Gesture *)jarg1;
30749   arg2 = (Dali::Gesture::State)jarg2;
30750   if (arg1) (arg1)->state = arg2;
30751 }
30752
30753
30754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30755   int jresult ;
30756   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30757   Dali::Gesture::State result;
30758
30759   arg1 = (Dali::Gesture *)jarg1;
30760   result = (Dali::Gesture::State) ((arg1)->state);
30761   jresult = (int)result;
30762   return jresult;
30763 }
30764
30765
30766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30767   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30768   unsigned int arg2 ;
30769
30770   arg1 = (Dali::Gesture *)jarg1;
30771   arg2 = (unsigned int)jarg2;
30772   if (arg1) (arg1)->time = arg2;
30773 }
30774
30775
30776 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30777   unsigned int jresult ;
30778   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30779   unsigned int result;
30780
30781   arg1 = (Dali::Gesture *)jarg1;
30782   result = (unsigned int) ((arg1)->time);
30783   jresult = result;
30784   return jresult;
30785 }
30786
30787
30788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30789   void * jresult ;
30790   Dali::HoverEvent *result = 0 ;
30791
30792   {
30793     try {
30794       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30795     } catch (std::out_of_range& e) {
30796       {
30797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30798       };
30799     } catch (std::exception& e) {
30800       {
30801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30802       };
30803     } catch (Dali::DaliException e) {
30804       {
30805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30806       };
30807     } catch (...) {
30808       {
30809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30810       };
30811     }
30812   }
30813
30814   jresult = (void *)result;
30815   return jresult;
30816 }
30817
30818
30819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30820   void * jresult ;
30821   unsigned long arg1 ;
30822   Dali::HoverEvent *result = 0 ;
30823
30824   arg1 = (unsigned long)jarg1;
30825   {
30826     try {
30827       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30828     } catch (std::out_of_range& e) {
30829       {
30830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30831       };
30832     } catch (std::exception& e) {
30833       {
30834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30835       };
30836     } catch (Dali::DaliException e) {
30837       {
30838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30839       };
30840     } catch (...) {
30841       {
30842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30843       };
30844     }
30845   }
30846
30847   jresult = (void *)result;
30848   return jresult;
30849 }
30850
30851
30852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30853   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30854
30855   arg1 = (Dali::HoverEvent *)jarg1;
30856   {
30857     try {
30858       delete arg1;
30859     } catch (std::out_of_range& e) {
30860       {
30861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30862       };
30863     } catch (std::exception& e) {
30864       {
30865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30866       };
30867     } catch (Dali::DaliException e) {
30868       {
30869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30870       };
30871     } catch (...) {
30872       {
30873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30874       };
30875     }
30876   }
30877
30878 }
30879
30880
30881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30882   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30883   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30884
30885   arg1 = (Dali::HoverEvent *)jarg1;
30886   arg2 = (Dali::TouchPointContainer *)jarg2;
30887   if (arg1) (arg1)->points = *arg2;
30888 }
30889
30890
30891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30892   void * jresult ;
30893   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30894   Dali::TouchPointContainer *result = 0 ;
30895
30896   arg1 = (Dali::HoverEvent *)jarg1;
30897   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30898   jresult = (void *)result;
30899   return jresult;
30900 }
30901
30902
30903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30904   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30905   unsigned long arg2 ;
30906
30907   arg1 = (Dali::HoverEvent *)jarg1;
30908   arg2 = (unsigned long)jarg2;
30909   if (arg1) (arg1)->time = arg2;
30910 }
30911
30912
30913 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30914   unsigned long jresult ;
30915   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30916   unsigned long result;
30917
30918   arg1 = (Dali::HoverEvent *)jarg1;
30919   result = (unsigned long) ((arg1)->time);
30920   jresult = (unsigned long)result;
30921   return jresult;
30922 }
30923
30924
30925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30926   unsigned int jresult ;
30927   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30928   unsigned int result;
30929
30930   arg1 = (Dali::HoverEvent *)jarg1;
30931   {
30932     try {
30933       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30934     } catch (std::out_of_range& e) {
30935       {
30936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30937       };
30938     } catch (std::exception& e) {
30939       {
30940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30941       };
30942     } catch (Dali::DaliException e) {
30943       {
30944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30945       };
30946     } catch (...) {
30947       {
30948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30949       };
30950     }
30951   }
30952
30953   jresult = result;
30954   return jresult;
30955 }
30956
30957
30958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30959   void * jresult ;
30960   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30961   unsigned int arg2 ;
30962   Dali::TouchPoint *result = 0 ;
30963
30964   arg1 = (Dali::HoverEvent *)jarg1;
30965   arg2 = (unsigned int)jarg2;
30966   {
30967     try {
30968       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30969     } catch (std::out_of_range& e) {
30970       {
30971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30972       };
30973     } catch (std::exception& e) {
30974       {
30975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30976       };
30977     } catch (Dali::DaliException e) {
30978       {
30979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30980       };
30981     } catch (...) {
30982       {
30983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30984       };
30985     }
30986   }
30987
30988   jresult = (void *)result;
30989   return jresult;
30990 }
30991
30992
30993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30994   void * jresult ;
30995   Dali::KeyEvent *result = 0 ;
30996
30997   {
30998     try {
30999       result = (Dali::KeyEvent *)new Dali::KeyEvent();
31000     } catch (std::out_of_range& e) {
31001       {
31002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31003       };
31004     } catch (std::exception& e) {
31005       {
31006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31007       };
31008     } catch (Dali::DaliException e) {
31009       {
31010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31011       };
31012     } catch (...) {
31013       {
31014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31015       };
31016     }
31017   }
31018
31019   jresult = (void *)result;
31020   return jresult;
31021 }
31022
31023
31024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31025   void * jresult ;
31026   std::string *arg1 = 0 ;
31027   std::string *arg2 = 0 ;
31028   int arg3 ;
31029   int arg4 ;
31030   unsigned long arg5 ;
31031   Dali::KeyEvent::State *arg6 = 0 ;
31032   Dali::KeyEvent::State temp6 ;
31033   Dali::KeyEvent *result = 0 ;
31034
31035   if (!jarg1) {
31036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31037     return 0;
31038   }
31039   std::string arg1_str(jarg1);
31040   arg1 = &arg1_str;
31041   if (!jarg2) {
31042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31043     return 0;
31044   }
31045   std::string arg2_str(jarg2);
31046   arg2 = &arg2_str;
31047   arg3 = (int)jarg3;
31048   arg4 = (int)jarg4;
31049   arg5 = (unsigned long)jarg5;
31050   temp6 = (Dali::KeyEvent::State)jarg6;
31051   arg6 = &temp6;
31052   {
31053     try {
31054       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31055     } catch (std::out_of_range& e) {
31056       {
31057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31058       };
31059     } catch (std::exception& e) {
31060       {
31061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31062       };
31063     } catch (Dali::DaliException e) {
31064       {
31065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31066       };
31067     } catch (...) {
31068       {
31069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31070       };
31071     }
31072   }
31073
31074   jresult = (void *)result;
31075
31076   //argout typemap for const std::string&
31077
31078
31079   //argout typemap for const std::string&
31080
31081   return jresult;
31082 }
31083
31084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31085   void * jresult ;
31086   Dali::KeyEvent *arg1 = 0 ;
31087   Dali::KeyEvent *result = 0 ;
31088
31089   arg1 = (Dali::KeyEvent *)jarg1;
31090   if (!arg1) {
31091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31092     return 0;
31093   }
31094   {
31095     try {
31096       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31097     } catch (std::out_of_range& e) {
31098       {
31099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31100       };
31101     } catch (std::exception& e) {
31102       {
31103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31104       };
31105     } catch (Dali::DaliException e) {
31106       {
31107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31108       };
31109     } catch (...) {
31110       {
31111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31112       };
31113     }
31114   }
31115
31116   jresult = (void *)result;
31117   return jresult;
31118 }
31119
31120
31121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31122   void * jresult ;
31123   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31124   Dali::KeyEvent *arg2 = 0 ;
31125   Dali::KeyEvent *result = 0 ;
31126
31127   arg1 = (Dali::KeyEvent *)jarg1;
31128   arg2 = (Dali::KeyEvent *)jarg2;
31129   if (!arg2) {
31130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31131     return 0;
31132   }
31133   {
31134     try {
31135       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31136     } catch (std::out_of_range& e) {
31137       {
31138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31139       };
31140     } catch (std::exception& e) {
31141       {
31142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31143       };
31144     } catch (Dali::DaliException e) {
31145       {
31146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31147       };
31148     } catch (...) {
31149       {
31150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31151       };
31152     }
31153   }
31154
31155   jresult = (void *)result;
31156   return jresult;
31157 }
31158
31159
31160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31161   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31162
31163   arg1 = (Dali::KeyEvent *)jarg1;
31164   {
31165     try {
31166       delete arg1;
31167     } catch (std::out_of_range& e) {
31168       {
31169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31170       };
31171     } catch (std::exception& e) {
31172       {
31173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31174       };
31175     } catch (Dali::DaliException e) {
31176       {
31177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31178       };
31179     } catch (...) {
31180       {
31181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31182       };
31183     }
31184   }
31185
31186 }
31187
31188
31189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31190   unsigned int jresult ;
31191   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31192   bool result;
31193
31194   arg1 = (Dali::KeyEvent *)jarg1;
31195   {
31196     try {
31197       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31198     } catch (std::out_of_range& e) {
31199       {
31200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31201       };
31202     } catch (std::exception& e) {
31203       {
31204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31205       };
31206     } catch (Dali::DaliException e) {
31207       {
31208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31209       };
31210     } catch (...) {
31211       {
31212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31213       };
31214     }
31215   }
31216
31217   jresult = result;
31218   return jresult;
31219 }
31220
31221
31222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31223   unsigned int jresult ;
31224   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31225   bool result;
31226
31227   arg1 = (Dali::KeyEvent *)jarg1;
31228   {
31229     try {
31230       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31231     } catch (std::out_of_range& e) {
31232       {
31233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31234       };
31235     } catch (std::exception& e) {
31236       {
31237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31238       };
31239     } catch (Dali::DaliException e) {
31240       {
31241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31242       };
31243     } catch (...) {
31244       {
31245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31246       };
31247     }
31248   }
31249
31250   jresult = result;
31251   return jresult;
31252 }
31253
31254
31255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31256   unsigned int jresult ;
31257   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31258   bool result;
31259
31260   arg1 = (Dali::KeyEvent *)jarg1;
31261   {
31262     try {
31263       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31264     } catch (std::out_of_range& e) {
31265       {
31266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31267       };
31268     } catch (std::exception& e) {
31269       {
31270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31271       };
31272     } catch (Dali::DaliException e) {
31273       {
31274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31275       };
31276     } catch (...) {
31277       {
31278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31279       };
31280     }
31281   }
31282
31283   jresult = result;
31284   return jresult;
31285 }
31286
31287
31288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31289   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31290   std::string *arg2 = 0 ;
31291
31292   arg1 = (Dali::KeyEvent *)jarg1;
31293   if (!jarg2) {
31294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31295     return ;
31296   }
31297   std::string arg2_str(jarg2);
31298   arg2 = &arg2_str;
31299   if (arg1) (arg1)->keyPressedName = *arg2;
31300
31301   //argout typemap for const std::string&
31302
31303 }
31304
31305
31306 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31307   char * jresult ;
31308
31309   if( jarg1 == NULL )
31310   {
31311     jresult = SWIG_csharp_string_callback( "" );
31312   }
31313   else
31314   {
31315     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31316     std::string *result = 0;
31317
31318     arg1 = ( Dali::KeyEvent * )jarg1;
31319     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31320     jresult = SWIG_csharp_string_callback( result->c_str() );
31321   }
31322
31323   return jresult;
31324 }
31325
31326
31327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31328   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31329   std::string *arg2 = 0 ;
31330
31331   arg1 = (Dali::KeyEvent *)jarg1;
31332   if (!jarg2) {
31333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31334     return ;
31335   }
31336   std::string arg2_str(jarg2);
31337   arg2 = &arg2_str;
31338   if (arg1) (arg1)->keyPressed = *arg2;
31339
31340   //argout typemap for const std::string&
31341
31342 }
31343
31344
31345 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31346   char * jresult ;
31347   if( NULL == jarg1 )
31348   {
31349     jresult = SWIG_csharp_string_callback( "" );
31350   }
31351   else
31352   {
31353     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31354     std::string *result = 0;
31355
31356     arg1 = ( Dali::KeyEvent * )jarg1;
31357     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31358     jresult = SWIG_csharp_string_callback( result->c_str() );
31359   }
31360   return jresult;
31361 }
31362
31363
31364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31365   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31366   int arg2 ;
31367
31368   arg1 = (Dali::KeyEvent *)jarg1;
31369   arg2 = (int)jarg2;
31370   if (arg1) (arg1)->keyCode = arg2;
31371 }
31372
31373
31374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31375   int jresult ;
31376   if( NULL == jarg1 )
31377   {
31378     jresult = -1;
31379   }
31380   else
31381   {
31382     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31383     int result;
31384
31385     arg1 = ( Dali::KeyEvent * )jarg1;
31386     result = (int)( ( arg1 )->keyCode );
31387     jresult = result;
31388   }
31389   return jresult;
31390 }
31391
31392
31393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31394   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31395   int arg2 ;
31396
31397   arg1 = (Dali::KeyEvent *)jarg1;
31398   arg2 = (int)jarg2;
31399   if (arg1) (arg1)->keyModifier = arg2;
31400 }
31401
31402
31403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31404   int jresult ;
31405   if( jarg1 == NULL )
31406   {
31407     jresult = -1;
31408   }
31409   else
31410   {
31411     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31412     int result;
31413
31414     arg1 = ( Dali::KeyEvent * )jarg1;
31415     result = (int)( ( arg1 )->keyModifier );
31416     jresult = result;
31417   }
31418   return jresult;
31419 }
31420
31421
31422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31423   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31424   unsigned long arg2 ;
31425
31426   arg1 = (Dali::KeyEvent *)jarg1;
31427   arg2 = (unsigned long)jarg2;
31428   if (arg1) (arg1)->time = arg2;
31429 }
31430
31431
31432 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31433   unsigned long jresult ;
31434   if( jarg1 == NULL )
31435   {
31436     jresult = 0;
31437   }
31438   else
31439   {
31440     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31441     unsigned long result;
31442
31443     arg1 = ( Dali::KeyEvent * )jarg1;
31444     result = (unsigned long)( ( arg1 )->time );
31445     jresult = (unsigned long)result;
31446   }
31447   return jresult;
31448 }
31449
31450
31451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31452   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31453   Dali::KeyEvent::State arg2 ;
31454
31455   arg1 = (Dali::KeyEvent *)jarg1;
31456   arg2 = (Dali::KeyEvent::State)jarg2;
31457   if (arg1) (arg1)->state = arg2;
31458 }
31459
31460
31461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31462   int jresult ;
31463   if( jarg1 == NULL )
31464   {
31465     jresult = -1;
31466   }
31467   else
31468   {
31469     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31470     Dali::KeyEvent::State result;
31471
31472     arg1 = ( Dali::KeyEvent * )jarg1;
31473     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31474     jresult = (int)result;
31475   }
31476   return jresult;
31477 }
31478
31479
31480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31481   void * jresult ;
31482   Dali::LongPressGestureDetector *result = 0 ;
31483
31484   {
31485     try {
31486       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31487     } catch (std::out_of_range& e) {
31488       {
31489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31490       };
31491     } catch (std::exception& e) {
31492       {
31493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31494       };
31495     } catch (Dali::DaliException e) {
31496       {
31497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31498       };
31499     } catch (...) {
31500       {
31501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31502       };
31503     }
31504   }
31505
31506   jresult = (void *)result;
31507   return jresult;
31508 }
31509
31510
31511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31512   void * jresult ;
31513   Dali::LongPressGestureDetector result;
31514
31515   {
31516     try {
31517       result = Dali::LongPressGestureDetector::New();
31518     } catch (std::out_of_range& e) {
31519       {
31520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31521       };
31522     } catch (std::exception& e) {
31523       {
31524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31525       };
31526     } catch (Dali::DaliException e) {
31527       {
31528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31529       };
31530     } catch (...) {
31531       {
31532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31533       };
31534     }
31535   }
31536
31537   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31538   return jresult;
31539 }
31540
31541
31542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31543   void * jresult ;
31544   unsigned int arg1 ;
31545   Dali::LongPressGestureDetector result;
31546
31547   arg1 = (unsigned int)jarg1;
31548   {
31549     try {
31550       result = Dali::LongPressGestureDetector::New(arg1);
31551     } catch (std::out_of_range& e) {
31552       {
31553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31554       };
31555     } catch (std::exception& e) {
31556       {
31557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31558       };
31559     } catch (Dali::DaliException e) {
31560       {
31561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31562       };
31563     } catch (...) {
31564       {
31565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31566       };
31567     }
31568   }
31569
31570   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31571   return jresult;
31572 }
31573
31574
31575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31576   void * jresult ;
31577   unsigned int arg1 ;
31578   unsigned int arg2 ;
31579   Dali::LongPressGestureDetector result;
31580
31581   arg1 = (unsigned int)jarg1;
31582   arg2 = (unsigned int)jarg2;
31583   {
31584     try {
31585       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31586     } catch (std::out_of_range& e) {
31587       {
31588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31589       };
31590     } catch (std::exception& e) {
31591       {
31592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31593       };
31594     } catch (Dali::DaliException e) {
31595       {
31596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31597       };
31598     } catch (...) {
31599       {
31600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31601       };
31602     }
31603   }
31604
31605   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31606   return jresult;
31607 }
31608
31609
31610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31611   void * jresult ;
31612   Dali::BaseHandle arg1 ;
31613   Dali::BaseHandle *argp1 ;
31614   Dali::LongPressGestureDetector result;
31615
31616   argp1 = (Dali::BaseHandle *)jarg1;
31617   if (!argp1) {
31618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31619     return 0;
31620   }
31621   arg1 = *argp1;
31622   {
31623     try {
31624       result = Dali::LongPressGestureDetector::DownCast(arg1);
31625     } catch (std::out_of_range& e) {
31626       {
31627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31628       };
31629     } catch (std::exception& e) {
31630       {
31631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31632       };
31633     } catch (Dali::DaliException e) {
31634       {
31635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31636       };
31637     } catch (...) {
31638       {
31639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31640       };
31641     }
31642   }
31643
31644   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31645   return jresult;
31646 }
31647
31648
31649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31650   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31651
31652   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31653   {
31654     try {
31655       delete arg1;
31656     } catch (std::out_of_range& e) {
31657       {
31658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31659       };
31660     } catch (std::exception& e) {
31661       {
31662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31663       };
31664     } catch (Dali::DaliException e) {
31665       {
31666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31667       };
31668     } catch (...) {
31669       {
31670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31671       };
31672     }
31673   }
31674
31675 }
31676
31677
31678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31679   void * jresult ;
31680   Dali::LongPressGestureDetector *arg1 = 0 ;
31681   Dali::LongPressGestureDetector *result = 0 ;
31682
31683   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31684   if (!arg1) {
31685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31686     return 0;
31687   }
31688   {
31689     try {
31690       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31691     } catch (std::out_of_range& e) {
31692       {
31693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31694       };
31695     } catch (std::exception& e) {
31696       {
31697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31698       };
31699     } catch (Dali::DaliException e) {
31700       {
31701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31702       };
31703     } catch (...) {
31704       {
31705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31706       };
31707     }
31708   }
31709
31710   jresult = (void *)result;
31711   return jresult;
31712 }
31713
31714
31715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31716   void * jresult ;
31717   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31718   Dali::LongPressGestureDetector *arg2 = 0 ;
31719   Dali::LongPressGestureDetector *result = 0 ;
31720
31721   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31722   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31723   if (!arg2) {
31724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31725     return 0;
31726   }
31727   {
31728     try {
31729       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31730     } catch (std::out_of_range& e) {
31731       {
31732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31733       };
31734     } catch (std::exception& e) {
31735       {
31736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31737       };
31738     } catch (Dali::DaliException e) {
31739       {
31740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31741       };
31742     } catch (...) {
31743       {
31744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31745       };
31746     }
31747   }
31748
31749   jresult = (void *)result;
31750   return jresult;
31751 }
31752
31753
31754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31755   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31756   unsigned int arg2 ;
31757
31758   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31759   arg2 = (unsigned int)jarg2;
31760   {
31761     try {
31762       (arg1)->SetTouchesRequired(arg2);
31763     } catch (std::out_of_range& e) {
31764       {
31765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31766       };
31767     } catch (std::exception& e) {
31768       {
31769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31770       };
31771     } catch (Dali::DaliException e) {
31772       {
31773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31774       };
31775     } catch (...) {
31776       {
31777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31778       };
31779     }
31780   }
31781
31782 }
31783
31784
31785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31786   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31787   unsigned int arg2 ;
31788   unsigned int arg3 ;
31789
31790   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31791   arg2 = (unsigned int)jarg2;
31792   arg3 = (unsigned int)jarg3;
31793   {
31794     try {
31795       (arg1)->SetTouchesRequired(arg2,arg3);
31796     } catch (std::out_of_range& e) {
31797       {
31798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31799       };
31800     } catch (std::exception& e) {
31801       {
31802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31803       };
31804     } catch (Dali::DaliException e) {
31805       {
31806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31807       };
31808     } catch (...) {
31809       {
31810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31811       };
31812     }
31813   }
31814
31815 }
31816
31817
31818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31819   unsigned int jresult ;
31820   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31821   unsigned int result;
31822
31823   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31824   {
31825     try {
31826       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31827     } catch (std::out_of_range& e) {
31828       {
31829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31830       };
31831     } catch (std::exception& e) {
31832       {
31833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31834       };
31835     } catch (Dali::DaliException e) {
31836       {
31837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31838       };
31839     } catch (...) {
31840       {
31841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31842       };
31843     }
31844   }
31845
31846   jresult = result;
31847   return jresult;
31848 }
31849
31850
31851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31852   unsigned int jresult ;
31853   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31854   unsigned int result;
31855
31856   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31857   {
31858     try {
31859       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31860     } catch (std::out_of_range& e) {
31861       {
31862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31863       };
31864     } catch (std::exception& e) {
31865       {
31866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31867       };
31868     } catch (Dali::DaliException e) {
31869       {
31870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31871       };
31872     } catch (...) {
31873       {
31874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31875       };
31876     }
31877   }
31878
31879   jresult = result;
31880   return jresult;
31881 }
31882
31883
31884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31885   void * jresult ;
31886   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31887   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31888
31889   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31890   {
31891     try {
31892       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31893     } catch (std::out_of_range& e) {
31894       {
31895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31896       };
31897     } catch (std::exception& e) {
31898       {
31899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31900       };
31901     } catch (Dali::DaliException e) {
31902       {
31903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31904       };
31905     } catch (...) {
31906       {
31907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31908       };
31909     }
31910   }
31911
31912   jresult = (void *)result;
31913   return jresult;
31914 }
31915
31916
31917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31918   void * jresult ;
31919   Dali::Gesture::State arg1 ;
31920   Dali::LongPressGesture *result = 0 ;
31921
31922   arg1 = (Dali::Gesture::State)jarg1;
31923   {
31924     try {
31925       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31926     } catch (std::out_of_range& e) {
31927       {
31928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31929       };
31930     } catch (std::exception& e) {
31931       {
31932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31933       };
31934     } catch (Dali::DaliException e) {
31935       {
31936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31937       };
31938     } catch (...) {
31939       {
31940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31941       };
31942     }
31943   }
31944
31945   jresult = (void *)result;
31946   return jresult;
31947 }
31948
31949
31950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31951   void * jresult ;
31952   Dali::LongPressGesture *arg1 = 0 ;
31953   Dali::LongPressGesture *result = 0 ;
31954
31955   arg1 = (Dali::LongPressGesture *)jarg1;
31956   if (!arg1) {
31957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31958     return 0;
31959   }
31960   {
31961     try {
31962       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*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_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31988   void * jresult ;
31989   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31990   Dali::LongPressGesture *arg2 = 0 ;
31991   Dali::LongPressGesture *result = 0 ;
31992
31993   arg1 = (Dali::LongPressGesture *)jarg1;
31994   arg2 = (Dali::LongPressGesture *)jarg2;
31995   if (!arg2) {
31996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31997     return 0;
31998   }
31999   {
32000     try {
32001       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
32002     } catch (std::out_of_range& e) {
32003       {
32004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32005       };
32006     } catch (std::exception& e) {
32007       {
32008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32009       };
32010     } catch (Dali::DaliException e) {
32011       {
32012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32013       };
32014     } catch (...) {
32015       {
32016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32017       };
32018     }
32019   }
32020
32021   jresult = (void *)result;
32022   return jresult;
32023 }
32024
32025
32026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32027   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32028
32029   arg1 = (Dali::LongPressGesture *)jarg1;
32030   {
32031     try {
32032       delete arg1;
32033     } catch (std::out_of_range& e) {
32034       {
32035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32036       };
32037     } catch (std::exception& e) {
32038       {
32039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32040       };
32041     } catch (Dali::DaliException e) {
32042       {
32043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32044       };
32045     } catch (...) {
32046       {
32047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32048       };
32049     }
32050   }
32051
32052 }
32053
32054
32055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32056   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32057   unsigned int arg2 ;
32058
32059   arg1 = (Dali::LongPressGesture *)jarg1;
32060   arg2 = (unsigned int)jarg2;
32061   if (arg1) (arg1)->numberOfTouches = arg2;
32062 }
32063
32064
32065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32066   unsigned int jresult ;
32067   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32068   unsigned int result;
32069
32070   arg1 = (Dali::LongPressGesture *)jarg1;
32071   result = (unsigned int) ((arg1)->numberOfTouches);
32072   jresult = result;
32073   return jresult;
32074 }
32075
32076
32077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32078   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32079   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32080
32081   arg1 = (Dali::LongPressGesture *)jarg1;
32082   arg2 = (Dali::Vector2 *)jarg2;
32083   if (arg1) (arg1)->screenPoint = *arg2;
32084 }
32085
32086
32087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32088   void * jresult ;
32089   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32090   Dali::Vector2 *result = 0 ;
32091
32092   arg1 = (Dali::LongPressGesture *)jarg1;
32093   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32094   jresult = (void *)result;
32095   return jresult;
32096 }
32097
32098
32099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32100   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32101   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32102
32103   arg1 = (Dali::LongPressGesture *)jarg1;
32104   arg2 = (Dali::Vector2 *)jarg2;
32105   if (arg1) (arg1)->localPoint = *arg2;
32106 }
32107
32108
32109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32110   void * jresult ;
32111   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32112   Dali::Vector2 *result = 0 ;
32113
32114   arg1 = (Dali::LongPressGesture *)jarg1;
32115   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32116   jresult = (void *)result;
32117   return jresult;
32118 }
32119
32120
32121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32122   void * jresult ;
32123   Dali::WheelEvent *result = 0 ;
32124
32125   {
32126     try {
32127       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32128     } catch (std::out_of_range& e) {
32129       {
32130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32131       };
32132     } catch (std::exception& e) {
32133       {
32134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32135       };
32136     } catch (Dali::DaliException e) {
32137       {
32138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32139       };
32140     } catch (...) {
32141       {
32142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32143       };
32144     }
32145   }
32146
32147   jresult = (void *)result;
32148   return jresult;
32149 }
32150
32151
32152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32153   void * jresult ;
32154   Dali::WheelEvent::Type arg1 ;
32155   int arg2 ;
32156   unsigned int arg3 ;
32157   Dali::Vector2 arg4 ;
32158   int arg5 ;
32159   unsigned int arg6 ;
32160   Dali::Vector2 *argp4 ;
32161   Dali::WheelEvent *result = 0 ;
32162
32163   arg1 = (Dali::WheelEvent::Type)jarg1;
32164   arg2 = (int)jarg2;
32165   arg3 = (unsigned int)jarg3;
32166   argp4 = (Dali::Vector2 *)jarg4;
32167   if (!argp4) {
32168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32169     return 0;
32170   }
32171   arg4 = *argp4;
32172   arg5 = (int)jarg5;
32173   arg6 = (unsigned int)jarg6;
32174   {
32175     try {
32176       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32177     } catch (std::out_of_range& e) {
32178       {
32179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32180       };
32181     } catch (std::exception& e) {
32182       {
32183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32184       };
32185     } catch (Dali::DaliException e) {
32186       {
32187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32188       };
32189     } catch (...) {
32190       {
32191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32192       };
32193     }
32194   }
32195
32196   jresult = (void *)result;
32197   return jresult;
32198 }
32199
32200
32201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32202   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32203
32204   arg1 = (Dali::WheelEvent *)jarg1;
32205   {
32206     try {
32207       delete arg1;
32208     } catch (std::out_of_range& e) {
32209       {
32210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32211       };
32212     } catch (std::exception& e) {
32213       {
32214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32215       };
32216     } catch (Dali::DaliException e) {
32217       {
32218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32219       };
32220     } catch (...) {
32221       {
32222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32223       };
32224     }
32225   }
32226
32227 }
32228
32229
32230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32231   unsigned int jresult ;
32232   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32233   bool result;
32234
32235   arg1 = (Dali::WheelEvent *)jarg1;
32236   {
32237     try {
32238       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32239     } catch (std::out_of_range& e) {
32240       {
32241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32242       };
32243     } catch (std::exception& e) {
32244       {
32245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32246       };
32247     } catch (Dali::DaliException e) {
32248       {
32249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32250       };
32251     } catch (...) {
32252       {
32253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32254       };
32255     }
32256   }
32257
32258   jresult = result;
32259   return jresult;
32260 }
32261
32262
32263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32264   unsigned int jresult ;
32265   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32266   bool result;
32267
32268   arg1 = (Dali::WheelEvent *)jarg1;
32269   {
32270     try {
32271       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32272     } catch (std::out_of_range& e) {
32273       {
32274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32275       };
32276     } catch (std::exception& e) {
32277       {
32278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32279       };
32280     } catch (Dali::DaliException e) {
32281       {
32282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32283       };
32284     } catch (...) {
32285       {
32286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32287       };
32288     }
32289   }
32290
32291   jresult = result;
32292   return jresult;
32293 }
32294
32295
32296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32297   unsigned int jresult ;
32298   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32299   bool result;
32300
32301   arg1 = (Dali::WheelEvent *)jarg1;
32302   {
32303     try {
32304       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32305     } catch (std::out_of_range& e) {
32306       {
32307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32308       };
32309     } catch (std::exception& e) {
32310       {
32311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32312       };
32313     } catch (Dali::DaliException e) {
32314       {
32315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32316       };
32317     } catch (...) {
32318       {
32319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32320       };
32321     }
32322   }
32323
32324   jresult = result;
32325   return jresult;
32326 }
32327
32328
32329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32330   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32331   Dali::WheelEvent::Type arg2 ;
32332
32333   arg1 = (Dali::WheelEvent *)jarg1;
32334   arg2 = (Dali::WheelEvent::Type)jarg2;
32335   if (arg1) (arg1)->type = arg2;
32336 }
32337
32338
32339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32340   int jresult ;
32341   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32342   Dali::WheelEvent::Type result;
32343
32344   arg1 = (Dali::WheelEvent *)jarg1;
32345   result = (Dali::WheelEvent::Type) ((arg1)->type);
32346   jresult = (int)result;
32347   return jresult;
32348 }
32349
32350
32351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32352   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32353   int arg2 ;
32354
32355   arg1 = (Dali::WheelEvent *)jarg1;
32356   arg2 = (int)jarg2;
32357   if (arg1) (arg1)->direction = arg2;
32358 }
32359
32360
32361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32362   int jresult ;
32363   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32364   int result;
32365
32366   arg1 = (Dali::WheelEvent *)jarg1;
32367   result = (int) ((arg1)->direction);
32368   jresult = result;
32369   return jresult;
32370 }
32371
32372
32373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32374   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32375   unsigned int arg2 ;
32376
32377   arg1 = (Dali::WheelEvent *)jarg1;
32378   arg2 = (unsigned int)jarg2;
32379   if (arg1) (arg1)->modifiers = arg2;
32380 }
32381
32382
32383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32384   unsigned int jresult ;
32385   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32386   unsigned int result;
32387
32388   arg1 = (Dali::WheelEvent *)jarg1;
32389   result = (unsigned int) ((arg1)->modifiers);
32390   jresult = result;
32391   return jresult;
32392 }
32393
32394
32395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32396   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32397   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32398
32399   arg1 = (Dali::WheelEvent *)jarg1;
32400   arg2 = (Dali::Vector2 *)jarg2;
32401   if (arg1) (arg1)->point = *arg2;
32402 }
32403
32404
32405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32406   void * jresult ;
32407   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32408   Dali::Vector2 *result = 0 ;
32409
32410   arg1 = (Dali::WheelEvent *)jarg1;
32411   result = (Dali::Vector2 *)& ((arg1)->point);
32412   jresult = (void *)result;
32413   return jresult;
32414 }
32415
32416
32417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32418   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32419   int arg2 ;
32420
32421   arg1 = (Dali::WheelEvent *)jarg1;
32422   arg2 = (int)jarg2;
32423   if (arg1) (arg1)->z = arg2;
32424 }
32425
32426
32427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32428   int jresult ;
32429   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32430   int result;
32431
32432   arg1 = (Dali::WheelEvent *)jarg1;
32433   result = (int) ((arg1)->z);
32434   jresult = result;
32435   return jresult;
32436 }
32437
32438
32439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32440   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32441   unsigned int arg2 ;
32442
32443   arg1 = (Dali::WheelEvent *)jarg1;
32444   arg2 = (unsigned int)jarg2;
32445   if (arg1) (arg1)->timeStamp = arg2;
32446 }
32447
32448
32449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32450   unsigned int jresult ;
32451   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32452   unsigned int result;
32453
32454   arg1 = (Dali::WheelEvent *)jarg1;
32455   result = (unsigned int) ((arg1)->timeStamp);
32456   jresult = result;
32457   return jresult;
32458 }
32459
32460 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32461   char * jresult ;
32462   Dali::KeyEvent *arg1 = 0 ;
32463   std::string result;
32464
32465   arg1 = (Dali::KeyEvent *)jarg1;
32466   if (!arg1) {
32467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32468     return 0;
32469   }
32470   {
32471     try {
32472       result = arg1->GetDeviceName();
32473     } catch (std::out_of_range& e) {
32474       {
32475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32476       };
32477     } catch (std::exception& e) {
32478       {
32479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32480       };
32481     } catch (Dali::DaliException e) {
32482       {
32483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32484       };
32485     } catch (...) {
32486       {
32487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32488       };
32489     }
32490   }
32491
32492   jresult = SWIG_csharp_string_callback((&result)->c_str());
32493   return jresult;
32494 }
32495
32496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32497   int jresult ;
32498   Dali::KeyEvent *arg1 = 0 ;
32499   Dali::Device::Class::Type result;
32500
32501   arg1 = (Dali::KeyEvent *)jarg1;
32502   if (!arg1) {
32503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32504     return 0;
32505   }
32506   {
32507     try {
32508       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32509     } catch (std::out_of_range& e) {
32510       {
32511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32512       };
32513     } catch (std::exception& e) {
32514       {
32515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32516       };
32517     } catch (Dali::DaliException e) {
32518       {
32519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32520       };
32521     } catch (...) {
32522       {
32523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32524       };
32525     }
32526   }
32527
32528   jresult = (int)result;
32529   return jresult;
32530 }
32531
32532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32533   int jresult ;
32534   Dali::KeyEvent *arg1 = 0 ;
32535   Dali::Device::Subclass::Type result;
32536
32537   arg1 = (Dali::KeyEvent *)jarg1;
32538   if (!arg1) {
32539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32540     return 0;
32541   }
32542   {
32543     try {
32544       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32545     } catch (std::out_of_range& e) {
32546       {
32547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32548       };
32549     } catch (std::exception& e) {
32550       {
32551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32552       };
32553     } catch (Dali::DaliException e) {
32554       {
32555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32556       };
32557     } catch (...) {
32558       {
32559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32560       };
32561     }
32562   }
32563
32564   jresult = (int)result;
32565   return jresult;
32566 }
32567
32568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32569   Dali::Actor arg1 ;
32570   Dali::Actor *argp1 ;
32571
32572   argp1 = (Dali::Actor *)jarg1;
32573   if (!argp1) {
32574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32575     return ;
32576   }
32577   arg1 = *argp1;
32578   {
32579     try {
32580       arg1.Raise();
32581     } catch (std::out_of_range& e) {
32582       {
32583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32584       };
32585     } catch (std::exception& e) {
32586       {
32587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32588       };
32589     } catch (Dali::DaliException e) {
32590       {
32591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32592       };
32593     } catch (...) {
32594       {
32595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32596       };
32597     }
32598   }
32599
32600 }
32601
32602
32603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32604   Dali::Actor arg1 ;
32605   Dali::Actor *argp1 ;
32606
32607   argp1 = (Dali::Actor *)jarg1;
32608   if (!argp1) {
32609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32610     return ;
32611   }
32612   arg1 = *argp1;
32613   {
32614     try {
32615       arg1.Lower();
32616     } catch (std::out_of_range& e) {
32617       {
32618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32619       };
32620     } catch (std::exception& e) {
32621       {
32622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32623       };
32624     } catch (Dali::DaliException e) {
32625       {
32626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32627       };
32628     } catch (...) {
32629       {
32630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32631       };
32632     }
32633   }
32634
32635 }
32636
32637
32638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32639   Dali::Actor arg1 ;
32640   Dali::Actor *argp1 ;
32641
32642   argp1 = (Dali::Actor *)jarg1;
32643   if (!argp1) {
32644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32645     return ;
32646   }
32647   arg1 = *argp1;
32648   {
32649     try {
32650       arg1.RaiseToTop();
32651     } catch (std::out_of_range& e) {
32652       {
32653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32654       };
32655     } catch (std::exception& e) {
32656       {
32657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32658       };
32659     } catch (Dali::DaliException e) {
32660       {
32661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32662       };
32663     } catch (...) {
32664       {
32665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32666       };
32667     }
32668   }
32669
32670 }
32671
32672
32673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32674   Dali::Actor arg1 ;
32675   Dali::Actor *argp1 ;
32676
32677   argp1 = (Dali::Actor *)jarg1;
32678   if (!argp1) {
32679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32680     return ;
32681   }
32682   arg1 = *argp1;
32683   {
32684     try {
32685       arg1.LowerToBottom();
32686     } catch (std::out_of_range& e) {
32687       {
32688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32689       };
32690     } catch (std::exception& e) {
32691       {
32692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32693       };
32694     } catch (Dali::DaliException e) {
32695       {
32696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32697       };
32698     } catch (...) {
32699       {
32700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32701       };
32702     }
32703   }
32704
32705 }
32706
32707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32708   Dali::Actor arg1 ;
32709   Dali::Actor arg2 ;
32710   Dali::Actor *argp1 ;
32711   Dali::Actor *argp2 ;
32712
32713   argp1 = (Dali::Actor *)jarg1;
32714   if (!argp1) {
32715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32716     return ;
32717   }
32718   arg1 = *argp1;
32719   argp2 = (Dali::Actor *)jarg2;
32720   if (!argp2) {
32721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32722     return ;
32723   }
32724   arg2 = *argp2;
32725   {
32726     try {
32727       arg1.RaiseAbove(arg2);
32728     } catch (std::out_of_range& e) {
32729       {
32730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32731       };
32732     } catch (std::exception& e) {
32733       {
32734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32735       };
32736     } catch (Dali::DaliException e) {
32737       {
32738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32739       };
32740     } catch (...) {
32741       {
32742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32743       };
32744     }
32745   }
32746
32747 }
32748
32749
32750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32751   Dali::Actor arg1 ;
32752   Dali::Actor arg2 ;
32753   Dali::Actor *argp1 ;
32754   Dali::Actor *argp2 ;
32755
32756   argp1 = (Dali::Actor *)jarg1;
32757   if (!argp1) {
32758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32759     return ;
32760   }
32761   arg1 = *argp1;
32762   argp2 = (Dali::Actor *)jarg2;
32763   if (!argp2) {
32764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32765     return ;
32766   }
32767   arg2 = *argp2;
32768   {
32769     try {
32770       arg1.LowerBelow(arg2);
32771     } catch (std::out_of_range& e) {
32772       {
32773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32774       };
32775     } catch (std::exception& e) {
32776       {
32777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32778       };
32779     } catch (Dali::DaliException e) {
32780       {
32781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32782       };
32783     } catch (...) {
32784       {
32785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32786       };
32787     }
32788   }
32789
32790 }
32791
32792
32793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32794   void * jresult ;
32795   Dali::Actor arg1 ;
32796   Dali::Actor *argp1 ;
32797   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32798
32799   argp1 = (Dali::Actor *)jarg1;
32800   if (!argp1) {
32801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32802     return 0;
32803   }
32804   arg1 = *argp1;
32805   {
32806     try {
32807       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32808     } catch (std::out_of_range& e) {
32809       {
32810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32811       };
32812     } catch (std::exception& e) {
32813       {
32814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32815       };
32816     } catch (Dali::DaliException e) {
32817       {
32818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32819       };
32820     } catch (...) {
32821       {
32822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32823       };
32824     }
32825   }
32826
32827   jresult = (void *)result;
32828   return jresult;
32829 }
32830
32831
32832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32833   void * jresult ;
32834   Dali::Actor *arg1 ;
32835   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32836
32837   arg1 = (Dali::Actor *)jarg1;
32838   {
32839     try {
32840       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32841     } catch (std::out_of_range& e) {
32842       {
32843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32844       };
32845     } catch (std::exception& e) {
32846       {
32847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32848       };
32849     } catch (Dali::DaliException e) {
32850       {
32851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32852       };
32853     } catch (...) {
32854       {
32855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32856       };
32857     }
32858   }
32859
32860   jresult = (void *)result;
32861   return jresult;
32862 }
32863
32864
32865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32866   int jresult ;
32867   int result;
32868
32869   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32870   jresult = (int)result;
32871   return jresult;
32872 }
32873
32874
32875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32876   int jresult ;
32877   int result;
32878
32879   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32880   jresult = (int)result;
32881   return jresult;
32882 }
32883
32884
32885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32886   int jresult ;
32887   int result;
32888
32889   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32890   jresult = (int)result;
32891   return jresult;
32892 }
32893
32894
32895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32896   int jresult ;
32897   int result;
32898
32899   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32900   jresult = (int)result;
32901   return jresult;
32902 }
32903
32904
32905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32906   int jresult ;
32907   int result;
32908
32909   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32910   jresult = (int)result;
32911   return jresult;
32912 }
32913
32914
32915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32916   int jresult ;
32917   int result;
32918
32919   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32920   jresult = (int)result;
32921   return jresult;
32922 }
32923
32924
32925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32926   int jresult ;
32927   int result;
32928
32929   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32930   jresult = (int)result;
32931   return jresult;
32932 }
32933
32934
32935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32936   int jresult ;
32937   int result;
32938
32939   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32940   jresult = (int)result;
32941   return jresult;
32942 }
32943
32944
32945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32946   int jresult ;
32947   int result;
32948
32949   result = (int)Dali::Actor::Property::SIZE;
32950   jresult = (int)result;
32951   return jresult;
32952 }
32953
32954
32955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32956   int jresult ;
32957   int result;
32958
32959   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32960   jresult = (int)result;
32961   return jresult;
32962 }
32963
32964
32965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32966   int jresult ;
32967   int result;
32968
32969   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32970   jresult = (int)result;
32971   return jresult;
32972 }
32973
32974
32975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32976   int jresult ;
32977   int result;
32978
32979   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32980   jresult = (int)result;
32981   return jresult;
32982 }
32983
32984
32985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32986   int jresult ;
32987   int result;
32988
32989   result = (int)Dali::Actor::Property::POSITION;
32990   jresult = (int)result;
32991   return jresult;
32992 }
32993
32994
32995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32996   int jresult ;
32997   int result;
32998
32999   result = (int)Dali::Actor::Property::POSITION_X;
33000   jresult = (int)result;
33001   return jresult;
33002 }
33003
33004
33005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
33006   int jresult ;
33007   int result;
33008
33009   result = (int)Dali::Actor::Property::POSITION_Y;
33010   jresult = (int)result;
33011   return jresult;
33012 }
33013
33014
33015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
33016   int jresult ;
33017   int result;
33018
33019   result = (int)Dali::Actor::Property::POSITION_Z;
33020   jresult = (int)result;
33021   return jresult;
33022 }
33023
33024
33025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33026   int jresult ;
33027   int result;
33028
33029   result = (int)Dali::Actor::Property::WORLD_POSITION;
33030   jresult = (int)result;
33031   return jresult;
33032 }
33033
33034
33035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33036   int jresult ;
33037   int result;
33038
33039   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33040   jresult = (int)result;
33041   return jresult;
33042 }
33043
33044
33045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33046   int jresult ;
33047   int result;
33048
33049   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33050   jresult = (int)result;
33051   return jresult;
33052 }
33053
33054
33055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33056   int jresult ;
33057   int result;
33058
33059   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33060   jresult = (int)result;
33061   return jresult;
33062 }
33063
33064
33065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33066   int jresult ;
33067   int result;
33068
33069   result = (int)Dali::Actor::Property::ORIENTATION;
33070   jresult = (int)result;
33071   return jresult;
33072 }
33073
33074
33075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33076   int jresult ;
33077   int result;
33078
33079   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33080   jresult = (int)result;
33081   return jresult;
33082 }
33083
33084
33085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33086   int jresult ;
33087   int result;
33088
33089   result = (int)Dali::Actor::Property::SCALE;
33090   jresult = (int)result;
33091   return jresult;
33092 }
33093
33094
33095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33096   int jresult ;
33097   int result;
33098
33099   result = (int)Dali::Actor::Property::SCALE_X;
33100   jresult = (int)result;
33101   return jresult;
33102 }
33103
33104
33105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33106   int jresult ;
33107   int result;
33108
33109   result = (int)Dali::Actor::Property::SCALE_Y;
33110   jresult = (int)result;
33111   return jresult;
33112 }
33113
33114
33115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33116   int jresult ;
33117   int result;
33118
33119   result = (int)Dali::Actor::Property::SCALE_Z;
33120   jresult = (int)result;
33121   return jresult;
33122 }
33123
33124
33125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33126   int jresult ;
33127   int result;
33128
33129   result = (int)Dali::Actor::Property::WORLD_SCALE;
33130   jresult = (int)result;
33131   return jresult;
33132 }
33133
33134
33135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33136   int jresult ;
33137   int result;
33138
33139   result = (int)Dali::Actor::Property::VISIBLE;
33140   jresult = (int)result;
33141   return jresult;
33142 }
33143
33144
33145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33146   int jresult ;
33147   int result;
33148
33149   result = (int)Dali::Actor::Property::COLOR;
33150   jresult = (int)result;
33151   return jresult;
33152 }
33153
33154
33155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33156   int jresult ;
33157   int result;
33158
33159   result = (int)Dali::Actor::Property::COLOR_RED;
33160   jresult = (int)result;
33161   return jresult;
33162 }
33163
33164
33165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33166   int jresult ;
33167   int result;
33168
33169   result = (int)Dali::Actor::Property::COLOR_GREEN;
33170   jresult = (int)result;
33171   return jresult;
33172 }
33173
33174
33175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33176   int jresult ;
33177   int result;
33178
33179   result = (int)Dali::Actor::Property::COLOR_BLUE;
33180   jresult = (int)result;
33181   return jresult;
33182 }
33183
33184
33185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33186   int jresult ;
33187   int result;
33188
33189   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33190   jresult = (int)result;
33191   return jresult;
33192 }
33193
33194
33195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33196   int jresult ;
33197   int result;
33198
33199   result = (int)Dali::Actor::Property::WORLD_COLOR;
33200   jresult = (int)result;
33201   return jresult;
33202 }
33203
33204
33205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33206   int jresult ;
33207   int result;
33208
33209   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33210   jresult = (int)result;
33211   return jresult;
33212 }
33213
33214
33215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33216   int jresult ;
33217   int result;
33218
33219   result = (int)Dali::Actor::Property::NAME;
33220   jresult = (int)result;
33221   return jresult;
33222 }
33223
33224
33225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33226   int jresult ;
33227   int result;
33228
33229   result = (int)Dali::Actor::Property::SENSITIVE;
33230   jresult = (int)result;
33231   return jresult;
33232 }
33233
33234
33235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33236   int jresult ;
33237   int result;
33238
33239   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33240   jresult = (int)result;
33241   return jresult;
33242 }
33243
33244
33245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33246   int jresult ;
33247   int result;
33248
33249   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33250   jresult = (int)result;
33251   return jresult;
33252 }
33253
33254
33255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33256   int jresult ;
33257   int result;
33258
33259   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33260   jresult = (int)result;
33261   return jresult;
33262 }
33263
33264
33265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33266   int jresult ;
33267   int result;
33268
33269   result = (int)Dali::Actor::Property::COLOR_MODE;
33270   jresult = (int)result;
33271   return jresult;
33272 }
33273
33274
33275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
33276   int jresult ;
33277   int result;
33278
33279   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
33280   jresult = (int)result;
33281   return jresult;
33282 }
33283
33284
33285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33286   int jresult ;
33287   int result;
33288
33289   result = (int)Dali::Actor::Property::DRAW_MODE;
33290   jresult = (int)result;
33291   return jresult;
33292 }
33293
33294
33295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33296   int jresult ;
33297   int result;
33298
33299   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33300   jresult = (int)result;
33301   return jresult;
33302 }
33303
33304
33305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33306   int jresult ;
33307   int result;
33308
33309   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33310   jresult = (int)result;
33311   return jresult;
33312 }
33313
33314
33315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33316   int jresult ;
33317   int result;
33318
33319   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33320   jresult = (int)result;
33321   return jresult;
33322 }
33323
33324
33325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33326   int jresult ;
33327   int result;
33328
33329   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33330   jresult = (int)result;
33331   return jresult;
33332 }
33333
33334
33335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33336   int jresult ;
33337   int result;
33338
33339   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33340   jresult = (int)result;
33341   return jresult;
33342 }
33343
33344
33345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33346   int jresult ;
33347   int result;
33348
33349   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33350   jresult = (int)result;
33351   return jresult;
33352 }
33353
33354
33355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33356   int jresult ;
33357   int result;
33358
33359   result = (int)Dali::Actor::Property::PADDING;
33360   jresult = (int)result;
33361   return jresult;
33362 }
33363
33364
33365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33366   int jresult ;
33367   int result;
33368
33369   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33370   jresult = (int)result;
33371   return jresult;
33372 }
33373
33374
33375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33376   int jresult ;
33377   int result;
33378
33379   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33380   jresult = (int)result;
33381   return jresult;
33382 }
33383
33384
33385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33386   int jresult ;
33387   int result;
33388
33389   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33390   jresult = (int)result;
33391   return jresult;
33392 }
33393
33394
33395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33396   int jresult ;
33397   int result;
33398
33399   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33400   jresult = (int)result;
33401   return jresult;
33402 }
33403
33404
33405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33406   void * jresult ;
33407   Dali::Actor::Property *result = 0 ;
33408
33409   {
33410     try {
33411       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33412     } catch (std::out_of_range& e) {
33413       {
33414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33415       };
33416     } catch (std::exception& e) {
33417       {
33418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33419       };
33420     } catch (Dali::DaliException e) {
33421       {
33422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33423       };
33424     } catch (...) {
33425       {
33426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33427       };
33428     }
33429   }
33430
33431   jresult = (void *)result;
33432   return jresult;
33433 }
33434
33435
33436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33437   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33438
33439   arg1 = (Dali::Actor::Property *)jarg1;
33440   {
33441     try {
33442       delete arg1;
33443     } catch (std::out_of_range& e) {
33444       {
33445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33446       };
33447     } catch (std::exception& e) {
33448       {
33449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33450       };
33451     } catch (Dali::DaliException e) {
33452       {
33453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33454       };
33455     } catch (...) {
33456       {
33457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33458       };
33459     }
33460   }
33461
33462 }
33463
33464
33465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33466   void * jresult ;
33467   Dali::Actor *result = 0 ;
33468
33469   {
33470     try {
33471       result = (Dali::Actor *)new Dali::Actor();
33472     } catch (std::out_of_range& e) {
33473       {
33474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33475       };
33476     } catch (std::exception& e) {
33477       {
33478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33479       };
33480     } catch (Dali::DaliException e) {
33481       {
33482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33483       };
33484     } catch (...) {
33485       {
33486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33487       };
33488     }
33489   }
33490
33491   jresult = (void *)result;
33492   return jresult;
33493 }
33494
33495
33496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33497   void * jresult ;
33498   Dali::Actor result;
33499
33500   {
33501     try {
33502       result = Dali::Actor::New();
33503     } catch (std::out_of_range& e) {
33504       {
33505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33506       };
33507     } catch (std::exception& e) {
33508       {
33509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33510       };
33511     } catch (Dali::DaliException e) {
33512       {
33513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33514       };
33515     } catch (...) {
33516       {
33517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33518       };
33519     }
33520   }
33521
33522   jresult = new Dali::Actor((const Dali::Actor &)result);
33523   return jresult;
33524 }
33525
33526
33527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33528   void * jresult ;
33529   Dali::BaseHandle arg1 ;
33530   Dali::BaseHandle *argp1 ;
33531   Dali::Actor result;
33532
33533   argp1 = (Dali::BaseHandle *)jarg1;
33534   if (!argp1) {
33535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33536     return 0;
33537   }
33538   arg1 = *argp1;
33539   {
33540     try {
33541       result = Dali::Actor::DownCast(arg1);
33542     } catch (std::out_of_range& e) {
33543       {
33544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33545       };
33546     } catch (std::exception& e) {
33547       {
33548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33549       };
33550     } catch (Dali::DaliException e) {
33551       {
33552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33553       };
33554     } catch (...) {
33555       {
33556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33557       };
33558     }
33559   }
33560
33561   jresult = new Dali::Actor((const Dali::Actor &)result);
33562   return jresult;
33563 }
33564
33565
33566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33567   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33568
33569   arg1 = (Dali::Actor *)jarg1;
33570   {
33571     try {
33572       delete arg1;
33573     } catch (std::out_of_range& e) {
33574       {
33575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33576       };
33577     } catch (std::exception& e) {
33578       {
33579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33580       };
33581     } catch (Dali::DaliException e) {
33582       {
33583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33584       };
33585     } catch (...) {
33586       {
33587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33588       };
33589     }
33590   }
33591
33592 }
33593
33594
33595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33596   void * jresult ;
33597   Dali::Actor *arg1 = 0 ;
33598   Dali::Actor *result = 0 ;
33599
33600   arg1 = (Dali::Actor *)jarg1;
33601   if (!arg1) {
33602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33603     return 0;
33604   }
33605   {
33606     try {
33607       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33608     } catch (std::out_of_range& e) {
33609       {
33610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33611       };
33612     } catch (std::exception& e) {
33613       {
33614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33615       };
33616     } catch (Dali::DaliException e) {
33617       {
33618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33619       };
33620     } catch (...) {
33621       {
33622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33623       };
33624     }
33625   }
33626
33627   jresult = (void *)result;
33628   return jresult;
33629 }
33630
33631
33632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33633   void * jresult ;
33634   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33635   Dali::Actor *arg2 = 0 ;
33636   Dali::Actor *result = 0 ;
33637
33638   arg1 = (Dali::Actor *)jarg1;
33639   arg2 = (Dali::Actor *)jarg2;
33640   if (!arg2) {
33641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33642     return 0;
33643   }
33644   {
33645     try {
33646       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33647     } catch (std::out_of_range& e) {
33648       {
33649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33650       };
33651     } catch (std::exception& e) {
33652       {
33653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33654       };
33655     } catch (Dali::DaliException e) {
33656       {
33657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33658       };
33659     } catch (...) {
33660       {
33661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33662       };
33663     }
33664   }
33665
33666   jresult = (void *)result;
33667   return jresult;
33668 }
33669
33670
33671 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33672   char * jresult ;
33673   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33674   std::string *result = 0 ;
33675
33676   arg1 = (Dali::Actor *)jarg1;
33677   {
33678     try {
33679       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33680     } catch (std::out_of_range& e) {
33681       {
33682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33683       };
33684     } catch (std::exception& e) {
33685       {
33686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33687       };
33688     } catch (Dali::DaliException e) {
33689       {
33690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33691       };
33692     } catch (...) {
33693       {
33694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33695       };
33696     }
33697   }
33698
33699   jresult = SWIG_csharp_string_callback(result->c_str());
33700   return jresult;
33701 }
33702
33703
33704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33705   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33706   std::string *arg2 = 0 ;
33707
33708   arg1 = (Dali::Actor *)jarg1;
33709   if (!jarg2) {
33710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33711     return ;
33712   }
33713   std::string arg2_str(jarg2);
33714   arg2 = &arg2_str;
33715   {
33716     try {
33717       (arg1)->SetName((std::string const &)*arg2);
33718     } catch (std::out_of_range& e) {
33719       {
33720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33721       };
33722     } catch (std::exception& e) {
33723       {
33724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33725       };
33726     } catch (Dali::DaliException e) {
33727       {
33728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33729       };
33730     } catch (...) {
33731       {
33732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33733       };
33734     }
33735   }
33736
33737
33738   //argout typemap for const std::string&
33739
33740 }
33741
33742
33743 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33744   unsigned int jresult ;
33745   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33746   unsigned int result;
33747
33748   arg1 = (Dali::Actor *)jarg1;
33749   {
33750     try {
33751       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33752     } catch (std::out_of_range& e) {
33753       {
33754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33755       };
33756     } catch (std::exception& e) {
33757       {
33758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33759       };
33760     } catch (Dali::DaliException e) {
33761       {
33762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33763       };
33764     } catch (...) {
33765       {
33766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33767       };
33768     }
33769   }
33770
33771   jresult = result;
33772   return jresult;
33773 }
33774
33775
33776 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33777   unsigned int jresult ;
33778   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33779   bool result;
33780
33781   arg1 = (Dali::Actor *)jarg1;
33782   {
33783     try {
33784       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33785     } catch (std::out_of_range& e) {
33786       {
33787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33788       };
33789     } catch (std::exception& e) {
33790       {
33791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33792       };
33793     } catch (Dali::DaliException e) {
33794       {
33795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33796       };
33797     } catch (...) {
33798       {
33799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33800       };
33801     }
33802   }
33803
33804   jresult = result;
33805   return jresult;
33806 }
33807
33808
33809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33810   unsigned int jresult ;
33811   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33812   bool result;
33813
33814   arg1 = (Dali::Actor *)jarg1;
33815   {
33816     try {
33817       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33818     } catch (std::out_of_range& e) {
33819       {
33820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33821       };
33822     } catch (std::exception& e) {
33823       {
33824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33825       };
33826     } catch (Dali::DaliException e) {
33827       {
33828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33829       };
33830     } catch (...) {
33831       {
33832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33833       };
33834     }
33835   }
33836
33837   jresult = result;
33838   return jresult;
33839 }
33840
33841
33842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33843   unsigned int jresult ;
33844   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33845   bool result;
33846
33847   arg1 = (Dali::Actor *)jarg1;
33848   {
33849     try {
33850       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33851     } catch (std::out_of_range& e) {
33852       {
33853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33854       };
33855     } catch (std::exception& e) {
33856       {
33857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33858       };
33859     } catch (Dali::DaliException e) {
33860       {
33861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33862       };
33863     } catch (...) {
33864       {
33865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33866       };
33867     }
33868   }
33869
33870   jresult = result;
33871   return jresult;
33872 }
33873
33874
33875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33876   void * jresult ;
33877   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33878   Dali::Layer result;
33879
33880   arg1 = (Dali::Actor *)jarg1;
33881   {
33882     try {
33883       result = (arg1)->GetLayer();
33884     } catch (std::out_of_range& e) {
33885       {
33886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33887       };
33888     } catch (std::exception& e) {
33889       {
33890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33891       };
33892     } catch (Dali::DaliException e) {
33893       {
33894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33895       };
33896     } catch (...) {
33897       {
33898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33899       };
33900     }
33901   }
33902
33903   jresult = new Dali::Layer((const Dali::Layer &)result);
33904   return jresult;
33905 }
33906
33907
33908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33909   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33910   Dali::Actor arg2 ;
33911   Dali::Actor *argp2 ;
33912
33913   arg1 = (Dali::Actor *)jarg1;
33914   argp2 = (Dali::Actor *)jarg2;
33915   if (!argp2) {
33916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33917     return ;
33918   }
33919   arg2 = *argp2;
33920   {
33921     try {
33922       (arg1)->Add(arg2);
33923     } catch (std::out_of_range& e) {
33924       {
33925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33926       };
33927     } catch (std::exception& e) {
33928       {
33929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33930       };
33931     } catch (Dali::DaliException e) {
33932       {
33933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33934       };
33935     } catch (...) {
33936       {
33937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33938       };
33939     }
33940   }
33941
33942 }
33943
33944
33945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(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)->Remove(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_Unparent(void * jarg1) {
33983   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33984
33985   arg1 = (Dali::Actor *)jarg1;
33986   {
33987     try {
33988       (arg1)->Unparent();
33989     } catch (std::out_of_range& e) {
33990       {
33991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33992       };
33993     } catch (std::exception& e) {
33994       {
33995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33996       };
33997     } catch (Dali::DaliException e) {
33998       {
33999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34000       };
34001     } catch (...) {
34002       {
34003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34004       };
34005     }
34006   }
34007
34008 }
34009
34010
34011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34012   unsigned int jresult ;
34013   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34014   unsigned int result;
34015
34016   arg1 = (Dali::Actor *)jarg1;
34017   {
34018     try {
34019       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34020     } catch (std::out_of_range& e) {
34021       {
34022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34023       };
34024     } catch (std::exception& e) {
34025       {
34026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34027       };
34028     } catch (Dali::DaliException e) {
34029       {
34030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34031       };
34032     } catch (...) {
34033       {
34034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34035       };
34036     }
34037   }
34038
34039   jresult = result;
34040   return jresult;
34041 }
34042
34043
34044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34045   void * jresult ;
34046   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34047   unsigned int arg2 ;
34048   Dali::Actor result;
34049
34050   arg1 = (Dali::Actor *)jarg1;
34051   arg2 = (unsigned int)jarg2;
34052   {
34053     try {
34054       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34055     } catch (std::out_of_range& e) {
34056       {
34057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34058       };
34059     } catch (std::exception& e) {
34060       {
34061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34062       };
34063     } catch (Dali::DaliException e) {
34064       {
34065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34066       };
34067     } catch (...) {
34068       {
34069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34070       };
34071     }
34072   }
34073
34074   jresult = new Dali::Actor((const Dali::Actor &)result);
34075   return jresult;
34076 }
34077
34078
34079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34080   void * jresult ;
34081   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34082   std::string *arg2 = 0 ;
34083   Dali::Actor result;
34084
34085   arg1 = (Dali::Actor *)jarg1;
34086   if (!jarg2) {
34087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34088     return 0;
34089   }
34090   std::string arg2_str(jarg2);
34091   arg2 = &arg2_str;
34092   {
34093     try {
34094       result = (arg1)->FindChildByName((std::string const &)*arg2);
34095     } catch (std::out_of_range& e) {
34096       {
34097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34098       };
34099     } catch (std::exception& e) {
34100       {
34101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34102       };
34103     } catch (Dali::DaliException e) {
34104       {
34105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34106       };
34107     } catch (...) {
34108       {
34109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34110       };
34111     }
34112   }
34113
34114   jresult = new Dali::Actor((const Dali::Actor &)result);
34115
34116   //argout typemap for const std::string&
34117
34118   return jresult;
34119 }
34120
34121
34122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34123   void * jresult ;
34124   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34125   unsigned int arg2 ;
34126   Dali::Actor result;
34127
34128   arg1 = (Dali::Actor *)jarg1;
34129   arg2 = (unsigned int)jarg2;
34130   {
34131     try {
34132       result = (arg1)->FindChildById(arg2);
34133     } catch (std::out_of_range& e) {
34134       {
34135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34136       };
34137     } catch (std::exception& e) {
34138       {
34139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34140       };
34141     } catch (Dali::DaliException e) {
34142       {
34143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34144       };
34145     } catch (...) {
34146       {
34147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34148       };
34149     }
34150   }
34151
34152   jresult = new Dali::Actor((const Dali::Actor &)result);
34153   return jresult;
34154 }
34155
34156
34157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34158   void * jresult ;
34159   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34160   Dali::Actor result;
34161
34162   arg1 = (Dali::Actor *)jarg1;
34163   {
34164     try {
34165       result = ((Dali::Actor const *)arg1)->GetParent();
34166     } catch (std::out_of_range& e) {
34167       {
34168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34169       };
34170     } catch (std::exception& e) {
34171       {
34172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34173       };
34174     } catch (Dali::DaliException e) {
34175       {
34176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34177       };
34178     } catch (...) {
34179       {
34180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34181       };
34182     }
34183   }
34184
34185   jresult = new Dali::Actor((const Dali::Actor &)result);
34186   return jresult;
34187 }
34188
34189
34190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34191   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34192   Dali::Vector3 *arg2 = 0 ;
34193
34194   arg1 = (Dali::Actor *)jarg1;
34195   arg2 = (Dali::Vector3 *)jarg2;
34196   if (!arg2) {
34197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34198     return ;
34199   }
34200   {
34201     try {
34202       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34203     } catch (std::out_of_range& e) {
34204       {
34205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34206       };
34207     } catch (std::exception& e) {
34208       {
34209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34210       };
34211     } catch (Dali::DaliException e) {
34212       {
34213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34214       };
34215     } catch (...) {
34216       {
34217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34218       };
34219     }
34220   }
34221
34222 }
34223
34224
34225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34226   void * jresult ;
34227   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34228   Dali::Vector3 result;
34229
34230   arg1 = (Dali::Actor *)jarg1;
34231   {
34232     try {
34233       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34234     } catch (std::out_of_range& e) {
34235       {
34236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34237       };
34238     } catch (std::exception& e) {
34239       {
34240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34241       };
34242     } catch (Dali::DaliException e) {
34243       {
34244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34245       };
34246     } catch (...) {
34247       {
34248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34249       };
34250     }
34251   }
34252
34253   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34254   return jresult;
34255 }
34256
34257
34258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34259   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34260   Dali::Vector3 *arg2 = 0 ;
34261
34262   arg1 = (Dali::Actor *)jarg1;
34263   arg2 = (Dali::Vector3 *)jarg2;
34264   if (!arg2) {
34265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34266     return ;
34267   }
34268   {
34269     try {
34270       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34271     } catch (std::out_of_range& e) {
34272       {
34273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34274       };
34275     } catch (std::exception& e) {
34276       {
34277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34278       };
34279     } catch (Dali::DaliException e) {
34280       {
34281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34282       };
34283     } catch (...) {
34284       {
34285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34286       };
34287     }
34288   }
34289
34290 }
34291
34292
34293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34294   void * jresult ;
34295   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34296   Dali::Vector3 result;
34297
34298   arg1 = (Dali::Actor *)jarg1;
34299   {
34300     try {
34301       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34302     } catch (std::out_of_range& e) {
34303       {
34304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34305       };
34306     } catch (std::exception& e) {
34307       {
34308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34309       };
34310     } catch (Dali::DaliException e) {
34311       {
34312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34313       };
34314     } catch (...) {
34315       {
34316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34317       };
34318     }
34319   }
34320
34321   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34322   return jresult;
34323 }
34324
34325
34326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34327   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34328   float arg2 ;
34329   float arg3 ;
34330
34331   arg1 = (Dali::Actor *)jarg1;
34332   arg2 = (float)jarg2;
34333   arg3 = (float)jarg3;
34334   {
34335     try {
34336       (arg1)->SetSize(arg2,arg3);
34337     } catch (std::out_of_range& e) {
34338       {
34339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34340       };
34341     } catch (std::exception& e) {
34342       {
34343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34344       };
34345     } catch (Dali::DaliException e) {
34346       {
34347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34348       };
34349     } catch (...) {
34350       {
34351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34352       };
34353     }
34354   }
34355
34356 }
34357
34358
34359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34360   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34361   float arg2 ;
34362   float arg3 ;
34363   float arg4 ;
34364
34365   arg1 = (Dali::Actor *)jarg1;
34366   arg2 = (float)jarg2;
34367   arg3 = (float)jarg3;
34368   arg4 = (float)jarg4;
34369   {
34370     try {
34371       (arg1)->SetSize(arg2,arg3,arg4);
34372     } catch (std::out_of_range& e) {
34373       {
34374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34375       };
34376     } catch (std::exception& e) {
34377       {
34378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34379       };
34380     } catch (Dali::DaliException e) {
34381       {
34382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34383       };
34384     } catch (...) {
34385       {
34386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34387       };
34388     }
34389   }
34390
34391 }
34392
34393
34394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34395   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34396   Dali::Vector2 *arg2 = 0 ;
34397
34398   arg1 = (Dali::Actor *)jarg1;
34399   arg2 = (Dali::Vector2 *)jarg2;
34400   if (!arg2) {
34401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34402     return ;
34403   }
34404   {
34405     try {
34406       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34407     } catch (std::out_of_range& e) {
34408       {
34409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34410       };
34411     } catch (std::exception& e) {
34412       {
34413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34414       };
34415     } catch (Dali::DaliException e) {
34416       {
34417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34418       };
34419     } catch (...) {
34420       {
34421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34422       };
34423     }
34424   }
34425
34426 }
34427
34428
34429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34430   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34431   Dali::Vector3 *arg2 = 0 ;
34432
34433   arg1 = (Dali::Actor *)jarg1;
34434   arg2 = (Dali::Vector3 *)jarg2;
34435   if (!arg2) {
34436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34437     return ;
34438   }
34439   {
34440     try {
34441       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34442     } catch (std::out_of_range& e) {
34443       {
34444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34445       };
34446     } catch (std::exception& e) {
34447       {
34448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34449       };
34450     } catch (Dali::DaliException e) {
34451       {
34452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34453       };
34454     } catch (...) {
34455       {
34456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34457       };
34458     }
34459   }
34460
34461 }
34462
34463
34464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34465   void * jresult ;
34466   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34467   Dali::Vector3 result;
34468
34469   arg1 = (Dali::Actor *)jarg1;
34470   {
34471     try {
34472       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34473     } catch (std::out_of_range& e) {
34474       {
34475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34476       };
34477     } catch (std::exception& e) {
34478       {
34479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34480       };
34481     } catch (Dali::DaliException e) {
34482       {
34483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34484       };
34485     } catch (...) {
34486       {
34487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34488       };
34489     }
34490   }
34491
34492   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34493   return jresult;
34494 }
34495
34496
34497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34498   void * jresult ;
34499   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34500   Dali::Vector3 result;
34501
34502   arg1 = (Dali::Actor *)jarg1;
34503   {
34504     try {
34505       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34506     } catch (std::out_of_range& e) {
34507       {
34508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34509       };
34510     } catch (std::exception& e) {
34511       {
34512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34513       };
34514     } catch (Dali::DaliException e) {
34515       {
34516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34517       };
34518     } catch (...) {
34519       {
34520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34521       };
34522     }
34523   }
34524
34525   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34526   return jresult;
34527 }
34528
34529
34530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34531   void * jresult ;
34532   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34533   Dali::Vector3 result;
34534
34535   arg1 = (Dali::Actor *)jarg1;
34536   {
34537     try {
34538       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34539     } catch (std::out_of_range& e) {
34540       {
34541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34542       };
34543     } catch (std::exception& e) {
34544       {
34545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34546       };
34547     } catch (Dali::DaliException e) {
34548       {
34549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34550       };
34551     } catch (...) {
34552       {
34553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34554       };
34555     }
34556   }
34557
34558   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34559   return jresult;
34560 }
34561
34562
34563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34564   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34565   float arg2 ;
34566   float arg3 ;
34567
34568   arg1 = (Dali::Actor *)jarg1;
34569   arg2 = (float)jarg2;
34570   arg3 = (float)jarg3;
34571   {
34572     try {
34573       (arg1)->SetPosition(arg2,arg3);
34574     } catch (std::out_of_range& e) {
34575       {
34576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34577       };
34578     } catch (std::exception& e) {
34579       {
34580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34581       };
34582     } catch (Dali::DaliException e) {
34583       {
34584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34585       };
34586     } catch (...) {
34587       {
34588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34589       };
34590     }
34591   }
34592
34593 }
34594
34595
34596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34597   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34598   float arg2 ;
34599   float arg3 ;
34600   float arg4 ;
34601
34602   arg1 = (Dali::Actor *)jarg1;
34603   arg2 = (float)jarg2;
34604   arg3 = (float)jarg3;
34605   arg4 = (float)jarg4;
34606   {
34607     try {
34608       (arg1)->SetPosition(arg2,arg3,arg4);
34609     } catch (std::out_of_range& e) {
34610       {
34611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34612       };
34613     } catch (std::exception& e) {
34614       {
34615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34616       };
34617     } catch (Dali::DaliException e) {
34618       {
34619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34620       };
34621     } catch (...) {
34622       {
34623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34624       };
34625     }
34626   }
34627
34628 }
34629
34630
34631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34632   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34633   Dali::Vector3 *arg2 = 0 ;
34634
34635   arg1 = (Dali::Actor *)jarg1;
34636   arg2 = (Dali::Vector3 *)jarg2;
34637   if (!arg2) {
34638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34639     return ;
34640   }
34641   {
34642     try {
34643       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34644     } catch (std::out_of_range& e) {
34645       {
34646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34647       };
34648     } catch (std::exception& e) {
34649       {
34650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34651       };
34652     } catch (Dali::DaliException e) {
34653       {
34654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34655       };
34656     } catch (...) {
34657       {
34658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34659       };
34660     }
34661   }
34662
34663 }
34664
34665
34666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34667   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34668   float arg2 ;
34669
34670   arg1 = (Dali::Actor *)jarg1;
34671   arg2 = (float)jarg2;
34672   {
34673     try {
34674       (arg1)->SetX(arg2);
34675     } catch (std::out_of_range& e) {
34676       {
34677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34678       };
34679     } catch (std::exception& e) {
34680       {
34681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34682       };
34683     } catch (Dali::DaliException e) {
34684       {
34685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34686       };
34687     } catch (...) {
34688       {
34689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34690       };
34691     }
34692   }
34693
34694 }
34695
34696
34697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34698   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34699   float arg2 ;
34700
34701   arg1 = (Dali::Actor *)jarg1;
34702   arg2 = (float)jarg2;
34703   {
34704     try {
34705       (arg1)->SetY(arg2);
34706     } catch (std::out_of_range& e) {
34707       {
34708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34709       };
34710     } catch (std::exception& e) {
34711       {
34712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34713       };
34714     } catch (Dali::DaliException e) {
34715       {
34716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34717       };
34718     } catch (...) {
34719       {
34720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34721       };
34722     }
34723   }
34724
34725 }
34726
34727
34728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34729   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34730   float arg2 ;
34731
34732   arg1 = (Dali::Actor *)jarg1;
34733   arg2 = (float)jarg2;
34734   {
34735     try {
34736       (arg1)->SetZ(arg2);
34737     } catch (std::out_of_range& e) {
34738       {
34739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34740       };
34741     } catch (std::exception& e) {
34742       {
34743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34744       };
34745     } catch (Dali::DaliException e) {
34746       {
34747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34748       };
34749     } catch (...) {
34750       {
34751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34752       };
34753     }
34754   }
34755
34756 }
34757
34758
34759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34760   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34761   Dali::Vector3 *arg2 = 0 ;
34762
34763   arg1 = (Dali::Actor *)jarg1;
34764   arg2 = (Dali::Vector3 *)jarg2;
34765   if (!arg2) {
34766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34767     return ;
34768   }
34769   {
34770     try {
34771       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34772     } catch (std::out_of_range& e) {
34773       {
34774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34775       };
34776     } catch (std::exception& e) {
34777       {
34778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34779       };
34780     } catch (Dali::DaliException e) {
34781       {
34782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34783       };
34784     } catch (...) {
34785       {
34786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34787       };
34788     }
34789   }
34790
34791 }
34792
34793
34794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34795   void * jresult ;
34796   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34797   Dali::Vector3 result;
34798
34799   arg1 = (Dali::Actor *)jarg1;
34800   {
34801     try {
34802       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34803     } catch (std::out_of_range& e) {
34804       {
34805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34806       };
34807     } catch (std::exception& e) {
34808       {
34809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34810       };
34811     } catch (Dali::DaliException e) {
34812       {
34813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34814       };
34815     } catch (...) {
34816       {
34817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34818       };
34819     }
34820   }
34821
34822   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34823   return jresult;
34824 }
34825
34826
34827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34828   void * jresult ;
34829   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34830   Dali::Vector3 result;
34831
34832   arg1 = (Dali::Actor *)jarg1;
34833   {
34834     try {
34835       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34836     } catch (std::out_of_range& e) {
34837       {
34838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34839       };
34840     } catch (std::exception& e) {
34841       {
34842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34843       };
34844     } catch (Dali::DaliException e) {
34845       {
34846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34847       };
34848     } catch (...) {
34849       {
34850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34851       };
34852     }
34853   }
34854
34855   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34856   return jresult;
34857 }
34858
34859
34860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34861   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34862   bool arg2 ;
34863
34864   arg1 = (Dali::Actor *)jarg1;
34865   arg2 = jarg2 ? true : false;
34866   {
34867     try {
34868       (arg1)->SetInheritPosition(arg2);
34869     } catch (std::out_of_range& e) {
34870       {
34871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34872       };
34873     } catch (std::exception& e) {
34874       {
34875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34876       };
34877     } catch (Dali::DaliException e) {
34878       {
34879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34880       };
34881     } catch (...) {
34882       {
34883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34884       };
34885     }
34886   }
34887
34888 }
34889
34890
34891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
34892   int jresult ;
34893   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34894   Dali::PositionInheritanceMode result;
34895
34896   arg1 = (Dali::Actor *)jarg1;
34897   {
34898     try {
34899       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
34900     } catch (std::out_of_range& e) {
34901       {
34902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34903       };
34904     } catch (std::exception& e) {
34905       {
34906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34907       };
34908     } catch (Dali::DaliException e) {
34909       {
34910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34911       };
34912     } catch (...) {
34913       {
34914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34915       };
34916     }
34917   }
34918
34919   jresult = (int)result;
34920   return jresult;
34921 }
34922
34923
34924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34925   unsigned int jresult ;
34926   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34927   bool result;
34928
34929   arg1 = (Dali::Actor *)jarg1;
34930   {
34931     try {
34932       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34933     } catch (std::out_of_range& e) {
34934       {
34935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34936       };
34937     } catch (std::exception& e) {
34938       {
34939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34940       };
34941     } catch (Dali::DaliException e) {
34942       {
34943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34944       };
34945     } catch (...) {
34946       {
34947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34948       };
34949     }
34950   }
34951
34952   jresult = result;
34953   return jresult;
34954 }
34955
34956
34957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34958   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34959   Dali::Degree *arg2 = 0 ;
34960   Dali::Vector3 *arg3 = 0 ;
34961
34962   arg1 = (Dali::Actor *)jarg1;
34963   arg2 = (Dali::Degree *)jarg2;
34964   if (!arg2) {
34965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34966     return ;
34967   }
34968   arg3 = (Dali::Vector3 *)jarg3;
34969   if (!arg3) {
34970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34971     return ;
34972   }
34973   {
34974     try {
34975       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34976     } catch (std::out_of_range& e) {
34977       {
34978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34979       };
34980     } catch (std::exception& e) {
34981       {
34982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34983       };
34984     } catch (Dali::DaliException e) {
34985       {
34986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34987       };
34988     } catch (...) {
34989       {
34990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34991       };
34992     }
34993   }
34994
34995 }
34996
34997
34998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34999   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35000   Dali::Radian *arg2 = 0 ;
35001   Dali::Vector3 *arg3 = 0 ;
35002
35003   arg1 = (Dali::Actor *)jarg1;
35004   arg2 = (Dali::Radian *)jarg2;
35005   if (!arg2) {
35006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35007     return ;
35008   }
35009   arg3 = (Dali::Vector3 *)jarg3;
35010   if (!arg3) {
35011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35012     return ;
35013   }
35014   {
35015     try {
35016       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35017     } catch (std::out_of_range& e) {
35018       {
35019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35020       };
35021     } catch (std::exception& e) {
35022       {
35023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35024       };
35025     } catch (Dali::DaliException e) {
35026       {
35027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35028       };
35029     } catch (...) {
35030       {
35031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35032       };
35033     }
35034   }
35035
35036 }
35037
35038
35039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35040   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35041   Dali::Quaternion *arg2 = 0 ;
35042
35043   arg1 = (Dali::Actor *)jarg1;
35044   arg2 = (Dali::Quaternion *)jarg2;
35045   if (!arg2) {
35046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35047     return ;
35048   }
35049   {
35050     try {
35051       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
35052     } catch (std::out_of_range& e) {
35053       {
35054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35055       };
35056     } catch (std::exception& e) {
35057       {
35058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35059       };
35060     } catch (Dali::DaliException e) {
35061       {
35062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35063       };
35064     } catch (...) {
35065       {
35066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35067       };
35068     }
35069   }
35070
35071 }
35072
35073
35074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35075   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35076   Dali::Degree *arg2 = 0 ;
35077   Dali::Vector3 *arg3 = 0 ;
35078
35079   arg1 = (Dali::Actor *)jarg1;
35080   arg2 = (Dali::Degree *)jarg2;
35081   if (!arg2) {
35082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35083     return ;
35084   }
35085   arg3 = (Dali::Vector3 *)jarg3;
35086   if (!arg3) {
35087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35088     return ;
35089   }
35090   {
35091     try {
35092       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35093     } catch (std::out_of_range& e) {
35094       {
35095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35096       };
35097     } catch (std::exception& e) {
35098       {
35099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35100       };
35101     } catch (Dali::DaliException e) {
35102       {
35103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35104       };
35105     } catch (...) {
35106       {
35107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35108       };
35109     }
35110   }
35111
35112 }
35113
35114
35115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35116   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35117   Dali::Radian *arg2 = 0 ;
35118   Dali::Vector3 *arg3 = 0 ;
35119
35120   arg1 = (Dali::Actor *)jarg1;
35121   arg2 = (Dali::Radian *)jarg2;
35122   if (!arg2) {
35123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35124     return ;
35125   }
35126   arg3 = (Dali::Vector3 *)jarg3;
35127   if (!arg3) {
35128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35129     return ;
35130   }
35131   {
35132     try {
35133       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35134     } catch (std::out_of_range& e) {
35135       {
35136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35137       };
35138     } catch (std::exception& e) {
35139       {
35140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35141       };
35142     } catch (Dali::DaliException e) {
35143       {
35144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35145       };
35146     } catch (...) {
35147       {
35148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35149       };
35150     }
35151   }
35152
35153 }
35154
35155
35156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35157   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35158   Dali::Quaternion *arg2 = 0 ;
35159
35160   arg1 = (Dali::Actor *)jarg1;
35161   arg2 = (Dali::Quaternion *)jarg2;
35162   if (!arg2) {
35163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35164     return ;
35165   }
35166   {
35167     try {
35168       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35169     } catch (std::out_of_range& e) {
35170       {
35171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35172       };
35173     } catch (std::exception& e) {
35174       {
35175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35176       };
35177     } catch (Dali::DaliException e) {
35178       {
35179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35180       };
35181     } catch (...) {
35182       {
35183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35184       };
35185     }
35186   }
35187
35188 }
35189
35190
35191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35192   void * jresult ;
35193   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35194   Dali::Quaternion result;
35195
35196   arg1 = (Dali::Actor *)jarg1;
35197   {
35198     try {
35199       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35200     } catch (std::out_of_range& e) {
35201       {
35202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35203       };
35204     } catch (std::exception& e) {
35205       {
35206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35207       };
35208     } catch (Dali::DaliException e) {
35209       {
35210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35211       };
35212     } catch (...) {
35213       {
35214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35215       };
35216     }
35217   }
35218
35219   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35220   return jresult;
35221 }
35222
35223
35224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35225   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35226   bool arg2 ;
35227
35228   arg1 = (Dali::Actor *)jarg1;
35229   arg2 = jarg2 ? true : false;
35230   {
35231     try {
35232       (arg1)->SetInheritOrientation(arg2);
35233     } catch (std::out_of_range& e) {
35234       {
35235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35236       };
35237     } catch (std::exception& e) {
35238       {
35239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35240       };
35241     } catch (Dali::DaliException e) {
35242       {
35243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35244       };
35245     } catch (...) {
35246       {
35247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35248       };
35249     }
35250   }
35251
35252 }
35253
35254
35255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35256   unsigned int jresult ;
35257   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35258   bool result;
35259
35260   arg1 = (Dali::Actor *)jarg1;
35261   {
35262     try {
35263       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35264     } catch (std::out_of_range& e) {
35265       {
35266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35267       };
35268     } catch (std::exception& e) {
35269       {
35270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35271       };
35272     } catch (Dali::DaliException e) {
35273       {
35274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35275       };
35276     } catch (...) {
35277       {
35278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35279       };
35280     }
35281   }
35282
35283   jresult = result;
35284   return jresult;
35285 }
35286
35287
35288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35289   void * jresult ;
35290   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35291   Dali::Quaternion result;
35292
35293   arg1 = (Dali::Actor *)jarg1;
35294   {
35295     try {
35296       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35297     } catch (std::out_of_range& e) {
35298       {
35299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35300       };
35301     } catch (std::exception& e) {
35302       {
35303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35304       };
35305     } catch (Dali::DaliException e) {
35306       {
35307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35308       };
35309     } catch (...) {
35310       {
35311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35312       };
35313     }
35314   }
35315
35316   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35317   return jresult;
35318 }
35319
35320
35321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35322   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35323   float arg2 ;
35324
35325   arg1 = (Dali::Actor *)jarg1;
35326   arg2 = (float)jarg2;
35327   {
35328     try {
35329       (arg1)->SetScale(arg2);
35330     } catch (std::out_of_range& e) {
35331       {
35332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35333       };
35334     } catch (std::exception& e) {
35335       {
35336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35337       };
35338     } catch (Dali::DaliException e) {
35339       {
35340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35341       };
35342     } catch (...) {
35343       {
35344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35345       };
35346     }
35347   }
35348
35349 }
35350
35351
35352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35353   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35354   float arg2 ;
35355   float arg3 ;
35356   float arg4 ;
35357
35358   arg1 = (Dali::Actor *)jarg1;
35359   arg2 = (float)jarg2;
35360   arg3 = (float)jarg3;
35361   arg4 = (float)jarg4;
35362   {
35363     try {
35364       (arg1)->SetScale(arg2,arg3,arg4);
35365     } catch (std::out_of_range& e) {
35366       {
35367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35368       };
35369     } catch (std::exception& e) {
35370       {
35371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35372       };
35373     } catch (Dali::DaliException e) {
35374       {
35375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35376       };
35377     } catch (...) {
35378       {
35379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35380       };
35381     }
35382   }
35383
35384 }
35385
35386
35387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35388   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35389   Dali::Vector3 *arg2 = 0 ;
35390
35391   arg1 = (Dali::Actor *)jarg1;
35392   arg2 = (Dali::Vector3 *)jarg2;
35393   if (!arg2) {
35394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35395     return ;
35396   }
35397   {
35398     try {
35399       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35400     } catch (std::out_of_range& e) {
35401       {
35402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35403       };
35404     } catch (std::exception& e) {
35405       {
35406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35407       };
35408     } catch (Dali::DaliException e) {
35409       {
35410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35411       };
35412     } catch (...) {
35413       {
35414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35415       };
35416     }
35417   }
35418
35419 }
35420
35421
35422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35423   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35424   Dali::Vector3 *arg2 = 0 ;
35425
35426   arg1 = (Dali::Actor *)jarg1;
35427   arg2 = (Dali::Vector3 *)jarg2;
35428   if (!arg2) {
35429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35430     return ;
35431   }
35432   {
35433     try {
35434       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35435     } catch (std::out_of_range& e) {
35436       {
35437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35438       };
35439     } catch (std::exception& e) {
35440       {
35441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35442       };
35443     } catch (Dali::DaliException e) {
35444       {
35445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35446       };
35447     } catch (...) {
35448       {
35449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35450       };
35451     }
35452   }
35453
35454 }
35455
35456
35457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35458   void * jresult ;
35459   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35460   Dali::Vector3 result;
35461
35462   arg1 = (Dali::Actor *)jarg1;
35463   {
35464     try {
35465       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35466     } catch (std::out_of_range& e) {
35467       {
35468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35469       };
35470     } catch (std::exception& e) {
35471       {
35472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35473       };
35474     } catch (Dali::DaliException e) {
35475       {
35476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35477       };
35478     } catch (...) {
35479       {
35480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35481       };
35482     }
35483   }
35484
35485   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35486   return jresult;
35487 }
35488
35489
35490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35491   void * jresult ;
35492   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35493   Dali::Vector3 result;
35494
35495   arg1 = (Dali::Actor *)jarg1;
35496   {
35497     try {
35498       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35499     } catch (std::out_of_range& e) {
35500       {
35501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35502       };
35503     } catch (std::exception& e) {
35504       {
35505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35506       };
35507     } catch (Dali::DaliException e) {
35508       {
35509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35510       };
35511     } catch (...) {
35512       {
35513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35514       };
35515     }
35516   }
35517
35518   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35519   return jresult;
35520 }
35521
35522
35523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35524   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35525   bool arg2 ;
35526
35527   arg1 = (Dali::Actor *)jarg1;
35528   arg2 = jarg2 ? true : false;
35529   {
35530     try {
35531       (arg1)->SetInheritScale(arg2);
35532     } catch (std::out_of_range& e) {
35533       {
35534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35535       };
35536     } catch (std::exception& e) {
35537       {
35538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35539       };
35540     } catch (Dali::DaliException e) {
35541       {
35542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35543       };
35544     } catch (...) {
35545       {
35546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35547       };
35548     }
35549   }
35550
35551 }
35552
35553
35554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35555   unsigned int jresult ;
35556   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35557   bool result;
35558
35559   arg1 = (Dali::Actor *)jarg1;
35560   {
35561     try {
35562       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35563     } catch (std::out_of_range& e) {
35564       {
35565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35566       };
35567     } catch (std::exception& e) {
35568       {
35569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35570       };
35571     } catch (Dali::DaliException e) {
35572       {
35573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35574       };
35575     } catch (...) {
35576       {
35577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35578       };
35579     }
35580   }
35581
35582   jresult = result;
35583   return jresult;
35584 }
35585
35586
35587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35588   void * jresult ;
35589   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35590   Dali::Matrix result;
35591
35592   arg1 = (Dali::Actor *)jarg1;
35593   {
35594     try {
35595       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35596     } catch (std::out_of_range& e) {
35597       {
35598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35599       };
35600     } catch (std::exception& e) {
35601       {
35602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35603       };
35604     } catch (Dali::DaliException e) {
35605       {
35606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35607       };
35608     } catch (...) {
35609       {
35610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35611       };
35612     }
35613   }
35614
35615   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35616   return jresult;
35617 }
35618
35619
35620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35621   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35622   bool arg2 ;
35623
35624   arg1 = (Dali::Actor *)jarg1;
35625   arg2 = jarg2 ? true : false;
35626   {
35627     try {
35628       (arg1)->SetVisible(arg2);
35629     } catch (std::out_of_range& e) {
35630       {
35631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35632       };
35633     } catch (std::exception& e) {
35634       {
35635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35636       };
35637     } catch (Dali::DaliException e) {
35638       {
35639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35640       };
35641     } catch (...) {
35642       {
35643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35644       };
35645     }
35646   }
35647
35648 }
35649
35650
35651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35652   unsigned int jresult ;
35653   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35654   bool result;
35655
35656   arg1 = (Dali::Actor *)jarg1;
35657   {
35658     try {
35659       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35660     } catch (std::out_of_range& e) {
35661       {
35662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35663       };
35664     } catch (std::exception& e) {
35665       {
35666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35667       };
35668     } catch (Dali::DaliException e) {
35669       {
35670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35671       };
35672     } catch (...) {
35673       {
35674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35675       };
35676     }
35677   }
35678
35679   jresult = result;
35680   return jresult;
35681 }
35682
35683
35684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35685   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35686   float arg2 ;
35687
35688   arg1 = (Dali::Actor *)jarg1;
35689   arg2 = (float)jarg2;
35690   {
35691     try {
35692       (arg1)->SetOpacity(arg2);
35693     } catch (std::out_of_range& e) {
35694       {
35695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35696       };
35697     } catch (std::exception& e) {
35698       {
35699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35700       };
35701     } catch (Dali::DaliException e) {
35702       {
35703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35704       };
35705     } catch (...) {
35706       {
35707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35708       };
35709     }
35710   }
35711
35712 }
35713
35714
35715 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35716   float jresult ;
35717   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35718   float result;
35719
35720   arg1 = (Dali::Actor *)jarg1;
35721   {
35722     try {
35723       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35724     } catch (std::out_of_range& e) {
35725       {
35726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35727       };
35728     } catch (std::exception& e) {
35729       {
35730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35731       };
35732     } catch (Dali::DaliException e) {
35733       {
35734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35735       };
35736     } catch (...) {
35737       {
35738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35739       };
35740     }
35741   }
35742
35743   jresult = result;
35744   return jresult;
35745 }
35746
35747
35748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35749   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35750   Dali::Vector4 *arg2 = 0 ;
35751
35752   arg1 = (Dali::Actor *)jarg1;
35753   arg2 = (Dali::Vector4 *)jarg2;
35754   if (!arg2) {
35755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35756     return ;
35757   }
35758   {
35759     try {
35760       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35761     } catch (std::out_of_range& e) {
35762       {
35763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35764       };
35765     } catch (std::exception& e) {
35766       {
35767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35768       };
35769     } catch (Dali::DaliException e) {
35770       {
35771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35772       };
35773     } catch (...) {
35774       {
35775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35776       };
35777     }
35778   }
35779
35780 }
35781
35782
35783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35784   void * jresult ;
35785   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35786   Dali::Vector4 result;
35787
35788   arg1 = (Dali::Actor *)jarg1;
35789   {
35790     try {
35791       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35792     } catch (std::out_of_range& e) {
35793       {
35794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35795       };
35796     } catch (std::exception& e) {
35797       {
35798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35799       };
35800     } catch (Dali::DaliException e) {
35801       {
35802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35803       };
35804     } catch (...) {
35805       {
35806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35807       };
35808     }
35809   }
35810
35811   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35812   return jresult;
35813 }
35814
35815
35816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35817   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35818   Dali::ColorMode arg2 ;
35819
35820   arg1 = (Dali::Actor *)jarg1;
35821   arg2 = (Dali::ColorMode)jarg2;
35822   {
35823     try {
35824       (arg1)->SetColorMode(arg2);
35825     } catch (std::out_of_range& e) {
35826       {
35827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35828       };
35829     } catch (std::exception& e) {
35830       {
35831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35832       };
35833     } catch (Dali::DaliException e) {
35834       {
35835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35836       };
35837     } catch (...) {
35838       {
35839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35840       };
35841     }
35842   }
35843
35844 }
35845
35846
35847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35848   int jresult ;
35849   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35850   Dali::ColorMode result;
35851
35852   arg1 = (Dali::Actor *)jarg1;
35853   {
35854     try {
35855       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35856     } catch (std::out_of_range& e) {
35857       {
35858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35859       };
35860     } catch (std::exception& e) {
35861       {
35862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35863       };
35864     } catch (Dali::DaliException e) {
35865       {
35866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35867       };
35868     } catch (...) {
35869       {
35870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35871       };
35872     }
35873   }
35874
35875   jresult = (int)result;
35876   return jresult;
35877 }
35878
35879
35880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35881   void * jresult ;
35882   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35883   Dali::Vector4 result;
35884
35885   arg1 = (Dali::Actor *)jarg1;
35886   {
35887     try {
35888       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35889     } catch (std::out_of_range& e) {
35890       {
35891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35892       };
35893     } catch (std::exception& e) {
35894       {
35895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35896       };
35897     } catch (Dali::DaliException e) {
35898       {
35899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35900       };
35901     } catch (...) {
35902       {
35903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35904       };
35905     }
35906   }
35907
35908   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35909   return jresult;
35910 }
35911
35912
35913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35914   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35915   Dali::DrawMode::Type arg2 ;
35916
35917   arg1 = (Dali::Actor *)jarg1;
35918   arg2 = (Dali::DrawMode::Type)jarg2;
35919   {
35920     try {
35921       (arg1)->SetDrawMode(arg2);
35922     } catch (std::out_of_range& e) {
35923       {
35924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35925       };
35926     } catch (std::exception& e) {
35927       {
35928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35929       };
35930     } catch (Dali::DaliException e) {
35931       {
35932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35933       };
35934     } catch (...) {
35935       {
35936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35937       };
35938     }
35939   }
35940
35941 }
35942
35943
35944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35945   int jresult ;
35946   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35947   Dali::DrawMode::Type result;
35948
35949   arg1 = (Dali::Actor *)jarg1;
35950   {
35951     try {
35952       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35953     } catch (std::out_of_range& e) {
35954       {
35955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35956       };
35957     } catch (std::exception& e) {
35958       {
35959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35960       };
35961     } catch (Dali::DaliException e) {
35962       {
35963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35964       };
35965     } catch (...) {
35966       {
35967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35968       };
35969     }
35970   }
35971
35972   jresult = (int)result;
35973   return jresult;
35974 }
35975
35976
35977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35978   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35979   bool arg2 ;
35980
35981   arg1 = (Dali::Actor *)jarg1;
35982   arg2 = jarg2 ? true : false;
35983   {
35984     try {
35985       (arg1)->SetSensitive(arg2);
35986     } catch (std::out_of_range& e) {
35987       {
35988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35989       };
35990     } catch (std::exception& e) {
35991       {
35992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35993       };
35994     } catch (Dali::DaliException e) {
35995       {
35996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35997       };
35998     } catch (...) {
35999       {
36000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36001       };
36002     }
36003   }
36004
36005 }
36006
36007
36008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
36009   unsigned int jresult ;
36010   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36011   bool result;
36012
36013   arg1 = (Dali::Actor *)jarg1;
36014   {
36015     try {
36016       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
36017     } catch (std::out_of_range& e) {
36018       {
36019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36020       };
36021     } catch (std::exception& e) {
36022       {
36023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36024       };
36025     } catch (Dali::DaliException e) {
36026       {
36027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36028       };
36029     } catch (...) {
36030       {
36031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36032       };
36033     }
36034   }
36035
36036   jresult = result;
36037   return jresult;
36038 }
36039
36040
36041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36042   unsigned int jresult ;
36043   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36044   float *arg2 = 0 ;
36045   float *arg3 = 0 ;
36046   float arg4 ;
36047   float arg5 ;
36048   bool result;
36049
36050   arg1 = (Dali::Actor *)jarg1;
36051   arg2 = (float *)jarg2;
36052   arg3 = (float *)jarg3;
36053   arg4 = (float)jarg4;
36054   arg5 = (float)jarg5;
36055   {
36056     try {
36057       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36058     } catch (std::out_of_range& e) {
36059       {
36060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36061       };
36062     } catch (std::exception& e) {
36063       {
36064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36065       };
36066     } catch (Dali::DaliException e) {
36067       {
36068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36069       };
36070     } catch (...) {
36071       {
36072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36073       };
36074     }
36075   }
36076
36077   jresult = result;
36078   return jresult;
36079 }
36080
36081
36082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36083   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36084   bool arg2 ;
36085
36086   arg1 = (Dali::Actor *)jarg1;
36087   arg2 = jarg2 ? true : false;
36088   {
36089     try {
36090       (arg1)->SetLeaveRequired(arg2);
36091     } catch (std::out_of_range& e) {
36092       {
36093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36094       };
36095     } catch (std::exception& e) {
36096       {
36097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36098       };
36099     } catch (Dali::DaliException e) {
36100       {
36101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36102       };
36103     } catch (...) {
36104       {
36105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36106       };
36107     }
36108   }
36109
36110 }
36111
36112
36113 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36114   unsigned int jresult ;
36115   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36116   bool result;
36117
36118   arg1 = (Dali::Actor *)jarg1;
36119   {
36120     try {
36121       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36122     } catch (std::out_of_range& e) {
36123       {
36124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36125       };
36126     } catch (std::exception& e) {
36127       {
36128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36129       };
36130     } catch (Dali::DaliException e) {
36131       {
36132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36133       };
36134     } catch (...) {
36135       {
36136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36137       };
36138     }
36139   }
36140
36141   jresult = result;
36142   return jresult;
36143 }
36144
36145
36146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36147   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36148   bool arg2 ;
36149
36150   arg1 = (Dali::Actor *)jarg1;
36151   arg2 = jarg2 ? true : false;
36152   {
36153     try {
36154       (arg1)->SetKeyboardFocusable(arg2);
36155     } catch (std::out_of_range& e) {
36156       {
36157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36158       };
36159     } catch (std::exception& e) {
36160       {
36161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36162       };
36163     } catch (Dali::DaliException e) {
36164       {
36165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36166       };
36167     } catch (...) {
36168       {
36169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36170       };
36171     }
36172   }
36173
36174 }
36175
36176
36177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36178   unsigned int jresult ;
36179   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36180   bool result;
36181
36182   arg1 = (Dali::Actor *)jarg1;
36183   {
36184     try {
36185       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36186     } catch (std::out_of_range& e) {
36187       {
36188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36189       };
36190     } catch (std::exception& e) {
36191       {
36192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36193       };
36194     } catch (Dali::DaliException e) {
36195       {
36196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36197       };
36198     } catch (...) {
36199       {
36200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36201       };
36202     }
36203   }
36204
36205   jresult = result;
36206   return jresult;
36207 }
36208
36209
36210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36211   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36212   Dali::ResizePolicy::Type arg2 ;
36213   Dali::Dimension::Type arg3 ;
36214
36215   arg1 = (Dali::Actor *)jarg1;
36216   arg2 = (Dali::ResizePolicy::Type)jarg2;
36217   arg3 = (Dali::Dimension::Type)jarg3;
36218   {
36219     try {
36220       (arg1)->SetResizePolicy(arg2,arg3);
36221     } catch (std::out_of_range& e) {
36222       {
36223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36224       };
36225     } catch (std::exception& e) {
36226       {
36227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36228       };
36229     } catch (Dali::DaliException e) {
36230       {
36231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36232       };
36233     } catch (...) {
36234       {
36235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36236       };
36237     }
36238   }
36239
36240 }
36241
36242
36243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36244   int jresult ;
36245   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36246   Dali::Dimension::Type arg2 ;
36247   Dali::ResizePolicy::Type result;
36248
36249   arg1 = (Dali::Actor *)jarg1;
36250   arg2 = (Dali::Dimension::Type)jarg2;
36251   {
36252     try {
36253       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36254     } catch (std::out_of_range& e) {
36255       {
36256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36257       };
36258     } catch (std::exception& e) {
36259       {
36260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36261       };
36262     } catch (Dali::DaliException e) {
36263       {
36264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36265       };
36266     } catch (...) {
36267       {
36268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36269       };
36270     }
36271   }
36272
36273   jresult = (int)result;
36274   return jresult;
36275 }
36276
36277
36278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36279   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36280   Dali::SizeScalePolicy::Type arg2 ;
36281
36282   arg1 = (Dali::Actor *)jarg1;
36283   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36284   {
36285     try {
36286       (arg1)->SetSizeScalePolicy(arg2);
36287     } catch (std::out_of_range& e) {
36288       {
36289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36290       };
36291     } catch (std::exception& e) {
36292       {
36293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36294       };
36295     } catch (Dali::DaliException e) {
36296       {
36297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36298       };
36299     } catch (...) {
36300       {
36301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36302       };
36303     }
36304   }
36305
36306 }
36307
36308
36309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36310   int jresult ;
36311   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36312   Dali::SizeScalePolicy::Type result;
36313
36314   arg1 = (Dali::Actor *)jarg1;
36315   {
36316     try {
36317       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36318     } catch (std::out_of_range& e) {
36319       {
36320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36321       };
36322     } catch (std::exception& e) {
36323       {
36324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36325       };
36326     } catch (Dali::DaliException e) {
36327       {
36328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36329       };
36330     } catch (...) {
36331       {
36332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36333       };
36334     }
36335   }
36336
36337   jresult = (int)result;
36338   return jresult;
36339 }
36340
36341
36342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36343   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36344   Dali::Vector3 *arg2 = 0 ;
36345
36346   arg1 = (Dali::Actor *)jarg1;
36347   arg2 = (Dali::Vector3 *)jarg2;
36348   if (!arg2) {
36349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36350     return ;
36351   }
36352   {
36353     try {
36354       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36355     } catch (std::out_of_range& e) {
36356       {
36357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36358       };
36359     } catch (std::exception& e) {
36360       {
36361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36362       };
36363     } catch (Dali::DaliException e) {
36364       {
36365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36366       };
36367     } catch (...) {
36368       {
36369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36370       };
36371     }
36372   }
36373
36374 }
36375
36376
36377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36378   void * jresult ;
36379   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36380   Dali::Vector3 result;
36381
36382   arg1 = (Dali::Actor *)jarg1;
36383   {
36384     try {
36385       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36386     } catch (std::out_of_range& e) {
36387       {
36388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36389       };
36390     } catch (std::exception& e) {
36391       {
36392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36393       };
36394     } catch (Dali::DaliException e) {
36395       {
36396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36397       };
36398     } catch (...) {
36399       {
36400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36401       };
36402     }
36403   }
36404
36405   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36406   return jresult;
36407 }
36408
36409
36410 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36411   float jresult ;
36412   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36413   float arg2 ;
36414   float result;
36415
36416   arg1 = (Dali::Actor *)jarg1;
36417   arg2 = (float)jarg2;
36418   {
36419     try {
36420       result = (float)(arg1)->GetHeightForWidth(arg2);
36421     } catch (std::out_of_range& e) {
36422       {
36423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36424       };
36425     } catch (std::exception& e) {
36426       {
36427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36428       };
36429     } catch (Dali::DaliException e) {
36430       {
36431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36432       };
36433     } catch (...) {
36434       {
36435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36436       };
36437     }
36438   }
36439
36440   jresult = result;
36441   return jresult;
36442 }
36443
36444
36445 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36446   float jresult ;
36447   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36448   float arg2 ;
36449   float result;
36450
36451   arg1 = (Dali::Actor *)jarg1;
36452   arg2 = (float)jarg2;
36453   {
36454     try {
36455       result = (float)(arg1)->GetWidthForHeight(arg2);
36456     } catch (std::out_of_range& e) {
36457       {
36458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36459       };
36460     } catch (std::exception& e) {
36461       {
36462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36463       };
36464     } catch (Dali::DaliException e) {
36465       {
36466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36467       };
36468     } catch (...) {
36469       {
36470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36471       };
36472     }
36473   }
36474
36475   jresult = result;
36476   return jresult;
36477 }
36478
36479
36480 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36481   float jresult ;
36482   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36483   Dali::Dimension::Type arg2 ;
36484   float result;
36485
36486   arg1 = (Dali::Actor *)jarg1;
36487   arg2 = (Dali::Dimension::Type)jarg2;
36488   {
36489     try {
36490       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36491     } catch (std::out_of_range& e) {
36492       {
36493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36494       };
36495     } catch (std::exception& e) {
36496       {
36497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36498       };
36499     } catch (Dali::DaliException e) {
36500       {
36501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36502       };
36503     } catch (...) {
36504       {
36505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36506       };
36507     }
36508   }
36509
36510   jresult = result;
36511   return jresult;
36512 }
36513
36514
36515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36516   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36517   Dali::Padding *arg2 = 0 ;
36518
36519   arg1 = (Dali::Actor *)jarg1;
36520   arg2 = (Dali::Padding *)jarg2;
36521   if (!arg2) {
36522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36523     return ;
36524   }
36525   {
36526     try {
36527       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36528     } catch (std::out_of_range& e) {
36529       {
36530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36531       };
36532     } catch (std::exception& e) {
36533       {
36534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36535       };
36536     } catch (Dali::DaliException e) {
36537       {
36538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36539       };
36540     } catch (...) {
36541       {
36542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36543       };
36544     }
36545   }
36546
36547 }
36548
36549
36550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36551   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36552   Dali::Padding *arg2 = 0 ;
36553
36554   arg1 = (Dali::Actor *)jarg1;
36555   arg2 = (Dali::Padding *)jarg2;
36556   if (!arg2) {
36557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36558     return ;
36559   }
36560   {
36561     try {
36562       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36563     } catch (std::out_of_range& e) {
36564       {
36565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36566       };
36567     } catch (std::exception& e) {
36568       {
36569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36570       };
36571     } catch (Dali::DaliException e) {
36572       {
36573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36574       };
36575     } catch (...) {
36576       {
36577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36578       };
36579     }
36580   }
36581
36582 }
36583
36584
36585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36586   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36587   Dali::Vector2 *arg2 = 0 ;
36588
36589   arg1 = (Dali::Actor *)jarg1;
36590   arg2 = (Dali::Vector2 *)jarg2;
36591   if (!arg2) {
36592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36593     return ;
36594   }
36595   {
36596     try {
36597       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36598     } catch (std::out_of_range& e) {
36599       {
36600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36601       };
36602     } catch (std::exception& e) {
36603       {
36604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36605       };
36606     } catch (Dali::DaliException e) {
36607       {
36608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36609       };
36610     } catch (...) {
36611       {
36612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36613       };
36614     }
36615   }
36616
36617 }
36618
36619
36620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36621   void * jresult ;
36622   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36623   Dali::Vector2 result;
36624
36625   arg1 = (Dali::Actor *)jarg1;
36626   {
36627     try {
36628       result = (arg1)->GetMinimumSize();
36629     } catch (std::out_of_range& e) {
36630       {
36631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36632       };
36633     } catch (std::exception& e) {
36634       {
36635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36636       };
36637     } catch (Dali::DaliException e) {
36638       {
36639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36640       };
36641     } catch (...) {
36642       {
36643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36644       };
36645     }
36646   }
36647
36648   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36649   return jresult;
36650 }
36651
36652
36653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36654   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36655   Dali::Vector2 *arg2 = 0 ;
36656
36657   arg1 = (Dali::Actor *)jarg1;
36658   arg2 = (Dali::Vector2 *)jarg2;
36659   if (!arg2) {
36660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36661     return ;
36662   }
36663   {
36664     try {
36665       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36666     } catch (std::out_of_range& e) {
36667       {
36668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36669       };
36670     } catch (std::exception& e) {
36671       {
36672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36673       };
36674     } catch (Dali::DaliException e) {
36675       {
36676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36677       };
36678     } catch (...) {
36679       {
36680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36681       };
36682     }
36683   }
36684
36685 }
36686
36687
36688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36689   void * jresult ;
36690   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36691   Dali::Vector2 result;
36692
36693   arg1 = (Dali::Actor *)jarg1;
36694   {
36695     try {
36696       result = (arg1)->GetMaximumSize();
36697     } catch (std::out_of_range& e) {
36698       {
36699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36700       };
36701     } catch (std::exception& e) {
36702       {
36703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36704       };
36705     } catch (Dali::DaliException e) {
36706       {
36707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36708       };
36709     } catch (...) {
36710       {
36711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36712       };
36713     }
36714   }
36715
36716   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36717   return jresult;
36718 }
36719
36720
36721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36722   int jresult ;
36723   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36724   int result;
36725
36726   arg1 = (Dali::Actor *)jarg1;
36727   {
36728     try {
36729       result = (int)(arg1)->GetHierarchyDepth();
36730     } catch (std::out_of_range& e) {
36731       {
36732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36733       };
36734     } catch (std::exception& e) {
36735       {
36736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36737       };
36738     } catch (Dali::DaliException e) {
36739       {
36740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36741       };
36742     } catch (...) {
36743       {
36744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36745       };
36746     }
36747   }
36748
36749   jresult = result;
36750   return jresult;
36751 }
36752
36753
36754 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36755   unsigned int jresult ;
36756   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36757   Dali::Renderer *arg2 = 0 ;
36758   unsigned int result;
36759
36760   arg1 = (Dali::Actor *)jarg1;
36761   arg2 = (Dali::Renderer *)jarg2;
36762   if (!arg2) {
36763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36764     return 0;
36765   }
36766   {
36767     try {
36768       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36769     } catch (std::out_of_range& e) {
36770       {
36771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36772       };
36773     } catch (std::exception& e) {
36774       {
36775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36776       };
36777     } catch (Dali::DaliException e) {
36778       {
36779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36780       };
36781     } catch (...) {
36782       {
36783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36784       };
36785     }
36786   }
36787
36788   jresult = result;
36789   return jresult;
36790 }
36791
36792
36793 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36794   unsigned int jresult ;
36795   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36796   unsigned int result;
36797
36798   arg1 = (Dali::Actor *)jarg1;
36799   {
36800     try {
36801       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36802     } catch (std::out_of_range& e) {
36803       {
36804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36805       };
36806     } catch (std::exception& e) {
36807       {
36808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36809       };
36810     } catch (Dali::DaliException e) {
36811       {
36812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36813       };
36814     } catch (...) {
36815       {
36816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36817       };
36818     }
36819   }
36820
36821   jresult = result;
36822   return jresult;
36823 }
36824
36825
36826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36827   void * jresult ;
36828   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36829   unsigned int arg2 ;
36830   Dali::Renderer result;
36831
36832   arg1 = (Dali::Actor *)jarg1;
36833   arg2 = (unsigned int)jarg2;
36834   {
36835     try {
36836       result = (arg1)->GetRendererAt(arg2);
36837     } catch (std::out_of_range& e) {
36838       {
36839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36840       };
36841     } catch (std::exception& e) {
36842       {
36843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36844       };
36845     } catch (Dali::DaliException e) {
36846       {
36847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36848       };
36849     } catch (...) {
36850       {
36851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36852       };
36853     }
36854   }
36855
36856   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36857   return jresult;
36858 }
36859
36860
36861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36862   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36863   Dali::Renderer *arg2 = 0 ;
36864
36865   arg1 = (Dali::Actor *)jarg1;
36866   arg2 = (Dali::Renderer *)jarg2;
36867   if (!arg2) {
36868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36869     return ;
36870   }
36871   {
36872     try {
36873       (arg1)->RemoveRenderer(*arg2);
36874     } catch (std::out_of_range& e) {
36875       {
36876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36877       };
36878     } catch (std::exception& e) {
36879       {
36880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36881       };
36882     } catch (Dali::DaliException e) {
36883       {
36884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36885       };
36886     } catch (...) {
36887       {
36888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36889       };
36890     }
36891   }
36892
36893 }
36894
36895
36896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36897   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36898   unsigned int arg2 ;
36899
36900   arg1 = (Dali::Actor *)jarg1;
36901   arg2 = (unsigned int)jarg2;
36902   {
36903     try {
36904       (arg1)->RemoveRenderer(arg2);
36905     } catch (std::out_of_range& e) {
36906       {
36907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36908       };
36909     } catch (std::exception& e) {
36910       {
36911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36912       };
36913     } catch (Dali::DaliException e) {
36914       {
36915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36916       };
36917     } catch (...) {
36918       {
36919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36920       };
36921     }
36922   }
36923
36924 }
36925
36926
36927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36928   void * jresult ;
36929   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36930   Dali::Actor::TouchSignalType *result = 0 ;
36931
36932   arg1 = (Dali::Actor *)jarg1;
36933   {
36934     try {
36935       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36936     } catch (std::out_of_range& e) {
36937       {
36938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36939       };
36940     } catch (std::exception& e) {
36941       {
36942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36943       };
36944     } catch (Dali::DaliException e) {
36945       {
36946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36947       };
36948     } catch (...) {
36949       {
36950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36951       };
36952     }
36953   }
36954
36955   jresult = (void *)result;
36956   return jresult;
36957 }
36958
36959
36960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36961   void * jresult ;
36962   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36963   Dali::Actor::TouchDataSignalType *result = 0 ;
36964
36965   arg1 = (Dali::Actor *)jarg1;
36966   {
36967     try {
36968       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36969     } catch (std::out_of_range& e) {
36970       {
36971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36972       };
36973     } catch (std::exception& e) {
36974       {
36975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36976       };
36977     } catch (Dali::DaliException e) {
36978       {
36979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36980       };
36981     } catch (...) {
36982       {
36983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36984       };
36985     }
36986   }
36987
36988   jresult = (void *)result;
36989   return jresult;
36990 }
36991
36992
36993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36994   void * jresult ;
36995   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36996   Dali::Actor::HoverSignalType *result = 0 ;
36997
36998   arg1 = (Dali::Actor *)jarg1;
36999   {
37000     try {
37001       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
37002     } catch (std::out_of_range& e) {
37003       {
37004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37005       };
37006     } catch (std::exception& e) {
37007       {
37008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37009       };
37010     } catch (Dali::DaliException e) {
37011       {
37012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37013       };
37014     } catch (...) {
37015       {
37016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37017       };
37018     }
37019   }
37020
37021   jresult = (void *)result;
37022   return jresult;
37023 }
37024
37025
37026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37027   void * jresult ;
37028   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37029   Dali::Actor::WheelEventSignalType *result = 0 ;
37030
37031   arg1 = (Dali::Actor *)jarg1;
37032   {
37033     try {
37034       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37035     } catch (std::out_of_range& e) {
37036       {
37037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37038       };
37039     } catch (std::exception& e) {
37040       {
37041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37042       };
37043     } catch (Dali::DaliException e) {
37044       {
37045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37046       };
37047     } catch (...) {
37048       {
37049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37050       };
37051     }
37052   }
37053
37054   jresult = (void *)result;
37055   return jresult;
37056 }
37057
37058
37059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37060   void * jresult ;
37061   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37062   Dali::Actor::OnStageSignalType *result = 0 ;
37063
37064   arg1 = (Dali::Actor *)jarg1;
37065   {
37066     try {
37067       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37068     } catch (std::out_of_range& e) {
37069       {
37070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37071       };
37072     } catch (std::exception& e) {
37073       {
37074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37075       };
37076     } catch (Dali::DaliException e) {
37077       {
37078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37079       };
37080     } catch (...) {
37081       {
37082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37083       };
37084     }
37085   }
37086
37087   jresult = (void *)result;
37088   return jresult;
37089 }
37090
37091
37092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37093   void * jresult ;
37094   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37095   Dali::Actor::OffStageSignalType *result = 0 ;
37096
37097   arg1 = (Dali::Actor *)jarg1;
37098   {
37099     try {
37100       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37101     } catch (std::out_of_range& e) {
37102       {
37103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37104       };
37105     } catch (std::exception& e) {
37106       {
37107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37108       };
37109     } catch (Dali::DaliException e) {
37110       {
37111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37112       };
37113     } catch (...) {
37114       {
37115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37116       };
37117     }
37118   }
37119
37120   jresult = (void *)result;
37121   return jresult;
37122 }
37123
37124
37125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37126   void * jresult ;
37127   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37128   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37129
37130   arg1 = (Dali::Actor *)jarg1;
37131   {
37132     try {
37133       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37134     } catch (std::out_of_range& e) {
37135       {
37136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37137       };
37138     } catch (std::exception& e) {
37139       {
37140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37141       };
37142     } catch (Dali::DaliException e) {
37143       {
37144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37145       };
37146     } catch (...) {
37147       {
37148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37149       };
37150     }
37151   }
37152
37153   jresult = (void *)result;
37154   return jresult;
37155 }
37156
37157
37158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37159   Dali::Actor *arg1 = 0 ;
37160
37161   arg1 = (Dali::Actor *)jarg1;
37162   if (!arg1) {
37163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37164     return ;
37165   }
37166   {
37167     try {
37168       Dali::UnparentAndReset(*arg1);
37169     } catch (std::out_of_range& e) {
37170       {
37171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37172       };
37173     } catch (std::exception& e) {
37174       {
37175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37176       };
37177     } catch (Dali::DaliException e) {
37178       {
37179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37180       };
37181     } catch (...) {
37182       {
37183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37184       };
37185     }
37186   }
37187
37188 }
37189
37190
37191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37192   int jresult ;
37193   int result;
37194
37195   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37196   jresult = (int)result;
37197   return jresult;
37198 }
37199
37200
37201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37202   int jresult ;
37203   int result;
37204
37205   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37206   jresult = (int)result;
37207   return jresult;
37208 }
37209
37210
37211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37212   int jresult ;
37213   int result;
37214
37215   result = (int)Dali::Layer::Property::BEHAVIOR;
37216   jresult = (int)result;
37217   return jresult;
37218 }
37219
37220
37221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37222   void * jresult ;
37223   Dali::Layer::Property *result = 0 ;
37224
37225   {
37226     try {
37227       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37228     } catch (std::out_of_range& e) {
37229       {
37230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37231       };
37232     } catch (std::exception& e) {
37233       {
37234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37235       };
37236     } catch (Dali::DaliException e) {
37237       {
37238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37239       };
37240     } catch (...) {
37241       {
37242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37243       };
37244     }
37245   }
37246
37247   jresult = (void *)result;
37248   return jresult;
37249 }
37250
37251
37252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37253   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37254
37255   arg1 = (Dali::Layer::Property *)jarg1;
37256   {
37257     try {
37258       delete arg1;
37259     } catch (std::out_of_range& e) {
37260       {
37261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37262       };
37263     } catch (std::exception& e) {
37264       {
37265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37266       };
37267     } catch (Dali::DaliException e) {
37268       {
37269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37270       };
37271     } catch (...) {
37272       {
37273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37274       };
37275     }
37276   }
37277
37278 }
37279
37280
37281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37282   void * jresult ;
37283   Dali::Layer *result = 0 ;
37284
37285   {
37286     try {
37287       result = (Dali::Layer *)new Dali::Layer();
37288     } catch (std::out_of_range& e) {
37289       {
37290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37291       };
37292     } catch (std::exception& e) {
37293       {
37294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37295       };
37296     } catch (Dali::DaliException e) {
37297       {
37298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37299       };
37300     } catch (...) {
37301       {
37302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37303       };
37304     }
37305   }
37306
37307   jresult = (void *)result;
37308   return jresult;
37309 }
37310
37311
37312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37313   void * jresult ;
37314   Dali::Layer result;
37315
37316   {
37317     try {
37318       result = Dali::Layer::New();
37319     } catch (std::out_of_range& e) {
37320       {
37321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37322       };
37323     } catch (std::exception& e) {
37324       {
37325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37326       };
37327     } catch (Dali::DaliException e) {
37328       {
37329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37330       };
37331     } catch (...) {
37332       {
37333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37334       };
37335     }
37336   }
37337
37338   jresult = new Dali::Layer((const Dali::Layer &)result);
37339   return jresult;
37340 }
37341
37342
37343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37344   void * jresult ;
37345   Dali::BaseHandle arg1 ;
37346   Dali::BaseHandle *argp1 ;
37347   Dali::Layer result;
37348
37349   argp1 = (Dali::BaseHandle *)jarg1;
37350   if (!argp1) {
37351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37352     return 0;
37353   }
37354   arg1 = *argp1;
37355   {
37356     try {
37357       result = Dali::Layer::DownCast(arg1);
37358     } catch (std::out_of_range& e) {
37359       {
37360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37361       };
37362     } catch (std::exception& e) {
37363       {
37364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37365       };
37366     } catch (Dali::DaliException e) {
37367       {
37368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37369       };
37370     } catch (...) {
37371       {
37372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37373       };
37374     }
37375   }
37376
37377   jresult = new Dali::Layer((const Dali::Layer &)result);
37378   return jresult;
37379 }
37380
37381
37382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37383   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37384
37385   arg1 = (Dali::Layer *)jarg1;
37386   {
37387     try {
37388       delete arg1;
37389     } catch (std::out_of_range& e) {
37390       {
37391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37392       };
37393     } catch (std::exception& e) {
37394       {
37395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37396       };
37397     } catch (Dali::DaliException e) {
37398       {
37399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37400       };
37401     } catch (...) {
37402       {
37403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37404       };
37405     }
37406   }
37407
37408 }
37409
37410
37411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37412   void * jresult ;
37413   Dali::Layer *arg1 = 0 ;
37414   Dali::Layer *result = 0 ;
37415
37416   arg1 = (Dali::Layer *)jarg1;
37417   if (!arg1) {
37418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37419     return 0;
37420   }
37421   {
37422     try {
37423       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37424     } catch (std::out_of_range& e) {
37425       {
37426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37427       };
37428     } catch (std::exception& e) {
37429       {
37430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37431       };
37432     } catch (Dali::DaliException e) {
37433       {
37434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37435       };
37436     } catch (...) {
37437       {
37438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37439       };
37440     }
37441   }
37442
37443   jresult = (void *)result;
37444   return jresult;
37445 }
37446
37447
37448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37449   void * jresult ;
37450   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37451   Dali::Layer *arg2 = 0 ;
37452   Dali::Layer *result = 0 ;
37453
37454   arg1 = (Dali::Layer *)jarg1;
37455   arg2 = (Dali::Layer *)jarg2;
37456   if (!arg2) {
37457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37458     return 0;
37459   }
37460   {
37461     try {
37462       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37463     } catch (std::out_of_range& e) {
37464       {
37465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37466       };
37467     } catch (std::exception& e) {
37468       {
37469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37470       };
37471     } catch (Dali::DaliException e) {
37472       {
37473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37474       };
37475     } catch (...) {
37476       {
37477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37478       };
37479     }
37480   }
37481
37482   jresult = (void *)result;
37483   return jresult;
37484 }
37485
37486
37487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37488   unsigned int jresult ;
37489   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37490   unsigned int result;
37491
37492   arg1 = (Dali::Layer *)jarg1;
37493   {
37494     try {
37495       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37496     } catch (std::out_of_range& e) {
37497       {
37498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37499       };
37500     } catch (std::exception& e) {
37501       {
37502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37503       };
37504     } catch (Dali::DaliException e) {
37505       {
37506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37507       };
37508     } catch (...) {
37509       {
37510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37511       };
37512     }
37513   }
37514
37515   jresult = result;
37516   return jresult;
37517 }
37518
37519
37520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37521   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37522
37523   arg1 = (Dali::Layer *)jarg1;
37524   {
37525     try {
37526       (arg1)->Raise();
37527     } catch (std::out_of_range& e) {
37528       {
37529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37530       };
37531     } catch (std::exception& e) {
37532       {
37533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37534       };
37535     } catch (Dali::DaliException e) {
37536       {
37537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37538       };
37539     } catch (...) {
37540       {
37541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37542       };
37543     }
37544   }
37545
37546 }
37547
37548
37549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37550   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37551
37552   arg1 = (Dali::Layer *)jarg1;
37553   {
37554     try {
37555       (arg1)->Lower();
37556     } catch (std::out_of_range& e) {
37557       {
37558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37559       };
37560     } catch (std::exception& e) {
37561       {
37562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37563       };
37564     } catch (Dali::DaliException e) {
37565       {
37566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37567       };
37568     } catch (...) {
37569       {
37570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37571       };
37572     }
37573   }
37574
37575 }
37576
37577
37578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37579   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37580   Dali::Layer arg2 ;
37581   Dali::Layer *argp2 ;
37582
37583   arg1 = (Dali::Layer *)jarg1;
37584   argp2 = (Dali::Layer *)jarg2;
37585   if (!argp2) {
37586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37587     return ;
37588   }
37589   arg2 = *argp2;
37590   {
37591     try {
37592       (arg1)->RaiseAbove(arg2);
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_LowerBelow(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)->LowerBelow(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_RaiseToTop(void * jarg1) {
37653   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37654
37655   arg1 = (Dali::Layer *)jarg1;
37656   {
37657     try {
37658       (arg1)->RaiseToTop();
37659     } catch (std::out_of_range& e) {
37660       {
37661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37662       };
37663     } catch (std::exception& e) {
37664       {
37665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37666       };
37667     } catch (Dali::DaliException e) {
37668       {
37669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37670       };
37671     } catch (...) {
37672       {
37673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37674       };
37675     }
37676   }
37677
37678 }
37679
37680
37681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37682   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37683
37684   arg1 = (Dali::Layer *)jarg1;
37685   {
37686     try {
37687       (arg1)->LowerToBottom();
37688     } catch (std::out_of_range& e) {
37689       {
37690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37691       };
37692     } catch (std::exception& e) {
37693       {
37694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37695       };
37696     } catch (Dali::DaliException e) {
37697       {
37698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37699       };
37700     } catch (...) {
37701       {
37702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37703       };
37704     }
37705   }
37706
37707 }
37708
37709
37710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37711   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37712   Dali::Layer arg2 ;
37713   Dali::Layer *argp2 ;
37714
37715   arg1 = (Dali::Layer *)jarg1;
37716   argp2 = (Dali::Layer *)jarg2;
37717   if (!argp2) {
37718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37719     return ;
37720   }
37721   arg2 = *argp2;
37722   {
37723     try {
37724       (arg1)->MoveAbove(arg2);
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_MoveBelow(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)->MoveBelow(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_SetBehavior(void * jarg1, int jarg2) {
37785   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37786   Dali::Layer::Behavior arg2 ;
37787
37788   arg1 = (Dali::Layer *)jarg1;
37789   arg2 = (Dali::Layer::Behavior)jarg2;
37790   {
37791     try {
37792       (arg1)->SetBehavior(arg2);
37793     } catch (std::out_of_range& e) {
37794       {
37795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37796       };
37797     } catch (std::exception& e) {
37798       {
37799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37800       };
37801     } catch (Dali::DaliException e) {
37802       {
37803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37804       };
37805     } catch (...) {
37806       {
37807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37808       };
37809     }
37810   }
37811
37812 }
37813
37814
37815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37816   int jresult ;
37817   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37818   Dali::Layer::Behavior result;
37819
37820   arg1 = (Dali::Layer *)jarg1;
37821   {
37822     try {
37823       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37824     } catch (std::out_of_range& e) {
37825       {
37826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37827       };
37828     } catch (std::exception& e) {
37829       {
37830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37831       };
37832     } catch (Dali::DaliException e) {
37833       {
37834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37835       };
37836     } catch (...) {
37837       {
37838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37839       };
37840     }
37841   }
37842
37843   jresult = (int)result;
37844   return jresult;
37845 }
37846
37847
37848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37849   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37850   bool arg2 ;
37851
37852   arg1 = (Dali::Layer *)jarg1;
37853   arg2 = jarg2 ? true : false;
37854   {
37855     try {
37856       (arg1)->SetClipping(arg2);
37857     } catch (std::out_of_range& e) {
37858       {
37859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37860       };
37861     } catch (std::exception& e) {
37862       {
37863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37864       };
37865     } catch (Dali::DaliException e) {
37866       {
37867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37868       };
37869     } catch (...) {
37870       {
37871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37872       };
37873     }
37874   }
37875
37876 }
37877
37878
37879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37880   unsigned int jresult ;
37881   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37882   bool result;
37883
37884   arg1 = (Dali::Layer *)jarg1;
37885   {
37886     try {
37887       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37888     } catch (std::out_of_range& e) {
37889       {
37890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37891       };
37892     } catch (std::exception& e) {
37893       {
37894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37895       };
37896     } catch (Dali::DaliException e) {
37897       {
37898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37899       };
37900     } catch (...) {
37901       {
37902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37903       };
37904     }
37905   }
37906
37907   jresult = result;
37908   return jresult;
37909 }
37910
37911
37912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37913   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37914   int arg2 ;
37915   int arg3 ;
37916   int arg4 ;
37917   int arg5 ;
37918
37919   arg1 = (Dali::Layer *)jarg1;
37920   arg2 = (int)jarg2;
37921   arg3 = (int)jarg3;
37922   arg4 = (int)jarg4;
37923   arg5 = (int)jarg5;
37924   {
37925     try {
37926       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37927     } catch (std::out_of_range& e) {
37928       {
37929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37930       };
37931     } catch (std::exception& e) {
37932       {
37933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37934       };
37935     } catch (Dali::DaliException e) {
37936       {
37937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37938       };
37939     } catch (...) {
37940       {
37941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37942       };
37943     }
37944   }
37945
37946 }
37947
37948
37949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37950   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37951   Dali::ClippingBox arg2 ;
37952   Dali::ClippingBox *argp2 ;
37953
37954   arg1 = (Dali::Layer *)jarg1;
37955   argp2 = (Dali::ClippingBox *)jarg2;
37956   if (!argp2) {
37957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37958     return ;
37959   }
37960   arg2 = *argp2;
37961   {
37962     try {
37963       (arg1)->SetClippingBox(arg2);
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_GetClippingBox(void * jarg1) {
37987   void * jresult ;
37988   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37989   Dali::ClippingBox result;
37990
37991   arg1 = (Dali::Layer *)jarg1;
37992   {
37993     try {
37994       result = ((Dali::Layer const *)arg1)->GetClippingBox();
37995     } catch (std::out_of_range& e) {
37996       {
37997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37998       };
37999     } catch (std::exception& e) {
38000       {
38001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38002       };
38003     } catch (Dali::DaliException e) {
38004       {
38005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38006       };
38007     } catch (...) {
38008       {
38009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38010       };
38011     }
38012   }
38013
38014   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
38015   return jresult;
38016 }
38017
38018
38019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38020   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38021   bool arg2 ;
38022
38023   arg1 = (Dali::Layer *)jarg1;
38024   arg2 = jarg2 ? true : false;
38025   {
38026     try {
38027       (arg1)->SetDepthTestDisabled(arg2);
38028     } catch (std::out_of_range& e) {
38029       {
38030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38031       };
38032     } catch (std::exception& e) {
38033       {
38034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38035       };
38036     } catch (Dali::DaliException e) {
38037       {
38038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38039       };
38040     } catch (...) {
38041       {
38042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38043       };
38044     }
38045   }
38046
38047 }
38048
38049
38050 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38051   unsigned int jresult ;
38052   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38053   bool result;
38054
38055   arg1 = (Dali::Layer *)jarg1;
38056   {
38057     try {
38058       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38059     } catch (std::out_of_range& e) {
38060       {
38061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38062       };
38063     } catch (std::exception& e) {
38064       {
38065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38066       };
38067     } catch (Dali::DaliException e) {
38068       {
38069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38070       };
38071     } catch (...) {
38072       {
38073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38074       };
38075     }
38076   }
38077
38078   jresult = result;
38079   return jresult;
38080 }
38081
38082
38083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38084   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38085   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38086
38087   arg1 = (Dali::Layer *)jarg1;
38088   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38089   {
38090     try {
38091       (arg1)->SetSortFunction(arg2);
38092     } catch (std::out_of_range& e) {
38093       {
38094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38095       };
38096     } catch (std::exception& e) {
38097       {
38098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38099       };
38100     } catch (Dali::DaliException e) {
38101       {
38102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38103       };
38104     } catch (...) {
38105       {
38106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38107       };
38108     }
38109   }
38110
38111 }
38112
38113
38114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38115   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38116   bool arg2 ;
38117
38118   arg1 = (Dali::Layer *)jarg1;
38119   arg2 = jarg2 ? true : false;
38120   {
38121     try {
38122       (arg1)->SetTouchConsumed(arg2);
38123     } catch (std::out_of_range& e) {
38124       {
38125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38126       };
38127     } catch (std::exception& e) {
38128       {
38129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38130       };
38131     } catch (Dali::DaliException e) {
38132       {
38133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38134       };
38135     } catch (...) {
38136       {
38137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38138       };
38139     }
38140   }
38141
38142 }
38143
38144
38145 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38146   unsigned int jresult ;
38147   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38148   bool result;
38149
38150   arg1 = (Dali::Layer *)jarg1;
38151   {
38152     try {
38153       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38154     } catch (std::out_of_range& e) {
38155       {
38156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38157       };
38158     } catch (std::exception& e) {
38159       {
38160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38161       };
38162     } catch (Dali::DaliException e) {
38163       {
38164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38165       };
38166     } catch (...) {
38167       {
38168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38169       };
38170     }
38171   }
38172
38173   jresult = result;
38174   return jresult;
38175 }
38176
38177
38178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38179   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38180   bool arg2 ;
38181
38182   arg1 = (Dali::Layer *)jarg1;
38183   arg2 = jarg2 ? true : false;
38184   {
38185     try {
38186       (arg1)->SetHoverConsumed(arg2);
38187     } catch (std::out_of_range& e) {
38188       {
38189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38190       };
38191     } catch (std::exception& e) {
38192       {
38193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38194       };
38195     } catch (Dali::DaliException e) {
38196       {
38197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38198       };
38199     } catch (...) {
38200       {
38201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38202       };
38203     }
38204   }
38205
38206 }
38207
38208
38209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38210   unsigned int jresult ;
38211   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38212   bool result;
38213
38214   arg1 = (Dali::Layer *)jarg1;
38215   {
38216     try {
38217       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38218     } catch (std::out_of_range& e) {
38219       {
38220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38221       };
38222     } catch (std::exception& e) {
38223       {
38224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38225       };
38226     } catch (Dali::DaliException e) {
38227       {
38228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38229       };
38230     } catch (...) {
38231       {
38232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38233       };
38234     }
38235   }
38236
38237   jresult = result;
38238   return jresult;
38239 }
38240
38241
38242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38243   void * jresult ;
38244   Dali::Vector4 *result = 0 ;
38245
38246   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38247   jresult = (void *)result;
38248   return jresult;
38249 }
38250
38251
38252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38253   void * jresult ;
38254   Dali::Vector4 *result = 0 ;
38255
38256   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38257   jresult = (void *)result;
38258   return jresult;
38259 }
38260
38261
38262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38263   void * jresult ;
38264   Dali::Stage *result = 0 ;
38265
38266   {
38267     try {
38268       result = (Dali::Stage *)new Dali::Stage();
38269     } catch (std::out_of_range& e) {
38270       {
38271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38272       };
38273     } catch (std::exception& e) {
38274       {
38275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38276       };
38277     } catch (Dali::DaliException e) {
38278       {
38279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38280       };
38281     } catch (...) {
38282       {
38283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38284       };
38285     }
38286   }
38287
38288   jresult = (void *)result;
38289   return jresult;
38290 }
38291
38292
38293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38294   void * jresult ;
38295   Dali::Stage result;
38296
38297   {
38298     try {
38299       result = Dali::Stage::GetCurrent();
38300     } catch (std::out_of_range& e) {
38301       {
38302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38303       };
38304     } catch (std::exception& e) {
38305       {
38306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38307       };
38308     } catch (Dali::DaliException e) {
38309       {
38310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38311       };
38312     } catch (...) {
38313       {
38314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38315       };
38316     }
38317   }
38318
38319   jresult = new Dali::Stage((const Dali::Stage &)result);
38320   return jresult;
38321 }
38322
38323
38324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38325   unsigned int jresult ;
38326   bool result;
38327
38328   {
38329     try {
38330       result = (bool)Dali::Stage::IsInstalled();
38331     } catch (std::out_of_range& e) {
38332       {
38333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38334       };
38335     } catch (std::exception& e) {
38336       {
38337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38338       };
38339     } catch (Dali::DaliException e) {
38340       {
38341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38342       };
38343     } catch (...) {
38344       {
38345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38346       };
38347     }
38348   }
38349
38350   jresult = result;
38351   return jresult;
38352 }
38353
38354
38355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38356   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38357
38358   arg1 = (Dali::Stage *)jarg1;
38359   {
38360     try {
38361       delete arg1;
38362     } catch (std::out_of_range& e) {
38363       {
38364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38365       };
38366     } catch (std::exception& e) {
38367       {
38368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38369       };
38370     } catch (Dali::DaliException e) {
38371       {
38372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38373       };
38374     } catch (...) {
38375       {
38376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38377       };
38378     }
38379   }
38380
38381 }
38382
38383
38384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38385   void * jresult ;
38386   Dali::Stage *arg1 = 0 ;
38387   Dali::Stage *result = 0 ;
38388
38389   arg1 = (Dali::Stage *)jarg1;
38390   if (!arg1) {
38391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38392     return 0;
38393   }
38394   {
38395     try {
38396       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38397     } catch (std::out_of_range& e) {
38398       {
38399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38400       };
38401     } catch (std::exception& e) {
38402       {
38403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38404       };
38405     } catch (Dali::DaliException e) {
38406       {
38407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38408       };
38409     } catch (...) {
38410       {
38411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38412       };
38413     }
38414   }
38415
38416   jresult = (void *)result;
38417   return jresult;
38418 }
38419
38420
38421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38422   void * jresult ;
38423   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38424   Dali::Stage *arg2 = 0 ;
38425   Dali::Stage *result = 0 ;
38426
38427   arg1 = (Dali::Stage *)jarg1;
38428   arg2 = (Dali::Stage *)jarg2;
38429   if (!arg2) {
38430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38431     return 0;
38432   }
38433   {
38434     try {
38435       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38436     } catch (std::out_of_range& e) {
38437       {
38438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38439       };
38440     } catch (std::exception& e) {
38441       {
38442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38443       };
38444     } catch (Dali::DaliException e) {
38445       {
38446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38447       };
38448     } catch (...) {
38449       {
38450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38451       };
38452     }
38453   }
38454
38455   jresult = (void *)result;
38456   return jresult;
38457 }
38458
38459
38460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38461   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38462   Dali::Actor *arg2 = 0 ;
38463
38464   arg1 = (Dali::Stage *)jarg1;
38465   arg2 = (Dali::Actor *)jarg2;
38466   if (!arg2) {
38467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38468     return ;
38469   }
38470   {
38471     try {
38472       (arg1)->Add(*arg2);
38473     } catch (std::out_of_range& e) {
38474       {
38475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38476       };
38477     } catch (std::exception& e) {
38478       {
38479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38480       };
38481     } catch (Dali::DaliException e) {
38482       {
38483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38484       };
38485     } catch (...) {
38486       {
38487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38488       };
38489     }
38490   }
38491
38492 }
38493
38494
38495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38496   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38497   Dali::Actor *arg2 = 0 ;
38498
38499   arg1 = (Dali::Stage *)jarg1;
38500   arg2 = (Dali::Actor *)jarg2;
38501   if (!arg2) {
38502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38503     return ;
38504   }
38505   {
38506     try {
38507       (arg1)->Remove(*arg2);
38508     } catch (std::out_of_range& e) {
38509       {
38510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38511       };
38512     } catch (std::exception& e) {
38513       {
38514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38515       };
38516     } catch (Dali::DaliException e) {
38517       {
38518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38519       };
38520     } catch (...) {
38521       {
38522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38523       };
38524     }
38525   }
38526
38527 }
38528
38529
38530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38531   void * jresult ;
38532   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38533   Dali::Vector2 result;
38534
38535   arg1 = (Dali::Stage *)jarg1;
38536   {
38537     try {
38538       result = ((Dali::Stage const *)arg1)->GetSize();
38539     } catch (std::out_of_range& e) {
38540       {
38541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38542       };
38543     } catch (std::exception& e) {
38544       {
38545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38546       };
38547     } catch (Dali::DaliException e) {
38548       {
38549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38550       };
38551     } catch (...) {
38552       {
38553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38554       };
38555     }
38556   }
38557
38558   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38559   return jresult;
38560 }
38561
38562
38563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38564   void * jresult ;
38565   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38566   Dali::RenderTaskList result;
38567
38568   arg1 = (Dali::Stage *)jarg1;
38569   {
38570     try {
38571       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38572     } catch (std::out_of_range& e) {
38573       {
38574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38575       };
38576     } catch (std::exception& e) {
38577       {
38578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38579       };
38580     } catch (Dali::DaliException e) {
38581       {
38582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38583       };
38584     } catch (...) {
38585       {
38586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38587       };
38588     }
38589   }
38590
38591   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38592   return jresult;
38593 }
38594
38595
38596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38597   unsigned int jresult ;
38598   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38599   unsigned int result;
38600
38601   arg1 = (Dali::Stage *)jarg1;
38602   {
38603     try {
38604       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38605     } catch (std::out_of_range& e) {
38606       {
38607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38608       };
38609     } catch (std::exception& e) {
38610       {
38611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38612       };
38613     } catch (Dali::DaliException e) {
38614       {
38615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38616       };
38617     } catch (...) {
38618       {
38619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38620       };
38621     }
38622   }
38623
38624   jresult = result;
38625   return jresult;
38626 }
38627
38628
38629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38630   void * jresult ;
38631   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38632   unsigned int arg2 ;
38633   Dali::Layer result;
38634
38635   arg1 = (Dali::Stage *)jarg1;
38636   arg2 = (unsigned int)jarg2;
38637   {
38638     try {
38639       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38640     } catch (std::out_of_range& e) {
38641       {
38642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38643       };
38644     } catch (std::exception& e) {
38645       {
38646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38647       };
38648     } catch (Dali::DaliException e) {
38649       {
38650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38651       };
38652     } catch (...) {
38653       {
38654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38655       };
38656     }
38657   }
38658
38659   jresult = new Dali::Layer((const Dali::Layer &)result);
38660   return jresult;
38661 }
38662
38663
38664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38665   void * jresult ;
38666   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38667   Dali::Layer result;
38668
38669   arg1 = (Dali::Stage *)jarg1;
38670   {
38671     try {
38672       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38673     } catch (std::out_of_range& e) {
38674       {
38675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38676       };
38677     } catch (std::exception& e) {
38678       {
38679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38680       };
38681     } catch (Dali::DaliException e) {
38682       {
38683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38684       };
38685     } catch (...) {
38686       {
38687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38688       };
38689     }
38690   }
38691
38692   jresult = new Dali::Layer((const Dali::Layer &)result);
38693   return jresult;
38694 }
38695
38696
38697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38698   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38699   Dali::Vector4 arg2 ;
38700   Dali::Vector4 *argp2 ;
38701
38702   arg1 = (Dali::Stage *)jarg1;
38703   argp2 = (Dali::Vector4 *)jarg2;
38704   if (!argp2) {
38705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38706     return ;
38707   }
38708   arg2 = *argp2;
38709   {
38710     try {
38711       (arg1)->SetBackgroundColor(arg2);
38712     } catch (std::out_of_range& e) {
38713       {
38714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38715       };
38716     } catch (std::exception& e) {
38717       {
38718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38719       };
38720     } catch (Dali::DaliException e) {
38721       {
38722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38723       };
38724     } catch (...) {
38725       {
38726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38727       };
38728     }
38729   }
38730
38731 }
38732
38733
38734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38735   void * jresult ;
38736   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38737   Dali::Vector4 result;
38738
38739   arg1 = (Dali::Stage *)jarg1;
38740   {
38741     try {
38742       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38743     } catch (std::out_of_range& e) {
38744       {
38745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38746       };
38747     } catch (std::exception& e) {
38748       {
38749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38750       };
38751     } catch (Dali::DaliException e) {
38752       {
38753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38754       };
38755     } catch (...) {
38756       {
38757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38758       };
38759     }
38760   }
38761
38762   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38763   return jresult;
38764 }
38765
38766
38767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38768   void * jresult ;
38769   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38770   Dali::Vector2 result;
38771
38772   arg1 = (Dali::Stage *)jarg1;
38773   {
38774     try {
38775       result = ((Dali::Stage const *)arg1)->GetDpi();
38776     } catch (std::out_of_range& e) {
38777       {
38778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38779       };
38780     } catch (std::exception& e) {
38781       {
38782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38783       };
38784     } catch (Dali::DaliException e) {
38785       {
38786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38787       };
38788     } catch (...) {
38789       {
38790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38791       };
38792     }
38793   }
38794
38795   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38796   return jresult;
38797 }
38798
38799
38800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38801   void * jresult ;
38802   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38803   Dali::ObjectRegistry result;
38804
38805   arg1 = (Dali::Stage *)jarg1;
38806   {
38807     try {
38808       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38809     } catch (std::out_of_range& e) {
38810       {
38811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38812       };
38813     } catch (std::exception& e) {
38814       {
38815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38816       };
38817     } catch (Dali::DaliException e) {
38818       {
38819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38820       };
38821     } catch (...) {
38822       {
38823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38824       };
38825     }
38826   }
38827
38828   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38829   return jresult;
38830 }
38831
38832
38833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38834   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38835   float arg2 ;
38836
38837   arg1 = (Dali::Stage *)jarg1;
38838   arg2 = (float)jarg2;
38839   {
38840     try {
38841       (arg1)->KeepRendering(arg2);
38842     } catch (std::out_of_range& e) {
38843       {
38844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38845       };
38846     } catch (std::exception& e) {
38847       {
38848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38849       };
38850     } catch (Dali::DaliException e) {
38851       {
38852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38853       };
38854     } catch (...) {
38855       {
38856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38857       };
38858     }
38859   }
38860
38861 }
38862
38863
38864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38865   void * jresult ;
38866   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38867   Dali::Stage::KeyEventSignalType *result = 0 ;
38868
38869   arg1 = (Dali::Stage *)jarg1;
38870   {
38871     try {
38872       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38873     } catch (std::out_of_range& e) {
38874       {
38875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38876       };
38877     } catch (std::exception& e) {
38878       {
38879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38880       };
38881     } catch (Dali::DaliException e) {
38882       {
38883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38884       };
38885     } catch (...) {
38886       {
38887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38888       };
38889     }
38890   }
38891
38892   jresult = (void *)result;
38893   return jresult;
38894 }
38895
38896
38897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38898   void * jresult ;
38899   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38900   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38901
38902   arg1 = (Dali::Stage *)jarg1;
38903   {
38904     try {
38905       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38906     } catch (std::out_of_range& e) {
38907       {
38908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38909       };
38910     } catch (std::exception& e) {
38911       {
38912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38913       };
38914     } catch (Dali::DaliException e) {
38915       {
38916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38917       };
38918     } catch (...) {
38919       {
38920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38921       };
38922     }
38923   }
38924
38925   jresult = (void *)result;
38926   return jresult;
38927 }
38928
38929
38930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38931   void * jresult ;
38932   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38933   Dali::Stage::TouchSignalType *result = 0 ;
38934
38935   arg1 = (Dali::Stage *)jarg1;
38936   {
38937     try {
38938       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38939     } catch (std::out_of_range& e) {
38940       {
38941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38942       };
38943     } catch (std::exception& e) {
38944       {
38945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38946       };
38947     } catch (Dali::DaliException e) {
38948       {
38949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38950       };
38951     } catch (...) {
38952       {
38953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38954       };
38955     }
38956   }
38957
38958   jresult = (void *)result;
38959   return jresult;
38960 }
38961
38962
38963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38964   void * jresult ;
38965   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38966   Dali::Stage::WheelEventSignalType *result = 0 ;
38967
38968   arg1 = (Dali::Stage *)jarg1;
38969   {
38970     try {
38971       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38972     } catch (std::out_of_range& e) {
38973       {
38974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38975       };
38976     } catch (std::exception& e) {
38977       {
38978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38979       };
38980     } catch (Dali::DaliException e) {
38981       {
38982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38983       };
38984     } catch (...) {
38985       {
38986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38987       };
38988     }
38989   }
38990
38991   jresult = (void *)result;
38992   return jresult;
38993 }
38994
38995
38996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38997   void * jresult ;
38998   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38999   Dali::Stage::ContextStatusSignal *result = 0 ;
39000
39001   arg1 = (Dali::Stage *)jarg1;
39002   {
39003     try {
39004       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
39005     } catch (std::out_of_range& e) {
39006       {
39007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39008       };
39009     } catch (std::exception& e) {
39010       {
39011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39012       };
39013     } catch (Dali::DaliException e) {
39014       {
39015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39016       };
39017     } catch (...) {
39018       {
39019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39020       };
39021     }
39022   }
39023
39024   jresult = (void *)result;
39025   return jresult;
39026 }
39027
39028
39029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39030   void * jresult ;
39031   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39032   Dali::Stage::ContextStatusSignal *result = 0 ;
39033
39034   arg1 = (Dali::Stage *)jarg1;
39035   {
39036     try {
39037       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39038     } catch (std::out_of_range& e) {
39039       {
39040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39041       };
39042     } catch (std::exception& e) {
39043       {
39044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39045       };
39046     } catch (Dali::DaliException e) {
39047       {
39048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39049       };
39050     } catch (...) {
39051       {
39052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39053       };
39054     }
39055   }
39056
39057   jresult = (void *)result;
39058   return jresult;
39059 }
39060
39061
39062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39063   void * jresult ;
39064   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39065   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39066
39067   arg1 = (Dali::Stage *)jarg1;
39068   {
39069     try {
39070       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39071     } catch (std::out_of_range& e) {
39072       {
39073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39074       };
39075     } catch (std::exception& e) {
39076       {
39077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39078       };
39079     } catch (Dali::DaliException e) {
39080       {
39081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39082       };
39083     } catch (...) {
39084       {
39085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39086       };
39087     }
39088   }
39089
39090   jresult = (void *)result;
39091   return jresult;
39092 }
39093
39094
39095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39096   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39097
39098   arg1 = (Dali::RelayoutContainer *)jarg1;
39099   {
39100     try {
39101       delete arg1;
39102     } catch (std::out_of_range& e) {
39103       {
39104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39105       };
39106     } catch (std::exception& e) {
39107       {
39108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39109       };
39110     } catch (Dali::DaliException e) {
39111       {
39112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39113       };
39114     } catch (...) {
39115       {
39116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39117       };
39118     }
39119   }
39120
39121 }
39122
39123
39124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39125   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39126   Dali::Actor *arg2 = 0 ;
39127   Dali::Vector2 *arg3 = 0 ;
39128
39129   arg1 = (Dali::RelayoutContainer *)jarg1;
39130   arg2 = (Dali::Actor *)jarg2;
39131   if (!arg2) {
39132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39133     return ;
39134   }
39135   arg3 = (Dali::Vector2 *)jarg3;
39136   if (!arg3) {
39137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39138     return ;
39139   }
39140   {
39141     try {
39142       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39143     } catch (std::out_of_range& e) {
39144       {
39145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39146       };
39147     } catch (std::exception& e) {
39148       {
39149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39150       };
39151     } catch (Dali::DaliException e) {
39152       {
39153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39154       };
39155     } catch (...) {
39156       {
39157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39158       };
39159     }
39160   }
39161
39162 }
39163
39164
39165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39166   void * jresult ;
39167   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39168   Dali::CustomActor result;
39169
39170   arg1 = (Dali::CustomActorImpl *)jarg1;
39171   {
39172     try {
39173       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39174     } catch (std::out_of_range& e) {
39175       {
39176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39177       };
39178     } catch (std::exception& e) {
39179       {
39180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39181       };
39182     } catch (Dali::DaliException e) {
39183       {
39184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39185       };
39186     } catch (...) {
39187       {
39188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39189       };
39190     }
39191   }
39192
39193   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39194   return jresult;
39195 }
39196
39197
39198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39199   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39200   int arg2 ;
39201
39202   arg1 = (Dali::CustomActorImpl *)jarg1;
39203   arg2 = (int)jarg2;
39204   {
39205     try {
39206       (arg1)->OnStageConnection(arg2);
39207     } catch (std::out_of_range& e) {
39208       {
39209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39210       };
39211     } catch (std::exception& e) {
39212       {
39213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39214       };
39215     } catch (Dali::DaliException e) {
39216       {
39217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39218       };
39219     } catch (...) {
39220       {
39221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39222       };
39223     }
39224   }
39225
39226 }
39227
39228
39229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39230   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39231
39232   arg1 = (Dali::CustomActorImpl *)jarg1;
39233   {
39234     try {
39235       (arg1)->OnStageDisconnection();
39236     } catch (std::out_of_range& e) {
39237       {
39238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39239       };
39240     } catch (std::exception& e) {
39241       {
39242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39243       };
39244     } catch (Dali::DaliException e) {
39245       {
39246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39247       };
39248     } catch (...) {
39249       {
39250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39251       };
39252     }
39253   }
39254
39255 }
39256
39257
39258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39259   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39260   Dali::Actor *arg2 = 0 ;
39261
39262   arg1 = (Dali::CustomActorImpl *)jarg1;
39263   arg2 = (Dali::Actor *)jarg2;
39264   if (!arg2) {
39265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39266     return ;
39267   }
39268   {
39269     try {
39270       (arg1)->OnChildAdd(*arg2);
39271     } catch (std::out_of_range& e) {
39272       {
39273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39274       };
39275     } catch (std::exception& e) {
39276       {
39277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39278       };
39279     } catch (Dali::DaliException e) {
39280       {
39281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39282       };
39283     } catch (...) {
39284       {
39285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39286       };
39287     }
39288   }
39289
39290 }
39291
39292
39293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39294   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39295   Dali::Actor *arg2 = 0 ;
39296
39297   arg1 = (Dali::CustomActorImpl *)jarg1;
39298   arg2 = (Dali::Actor *)jarg2;
39299   if (!arg2) {
39300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39301     return ;
39302   }
39303   {
39304     try {
39305       (arg1)->OnChildRemove(*arg2);
39306     } catch (std::out_of_range& e) {
39307       {
39308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39309       };
39310     } catch (std::exception& e) {
39311       {
39312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39313       };
39314     } catch (Dali::DaliException e) {
39315       {
39316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39317       };
39318     } catch (...) {
39319       {
39320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39321       };
39322     }
39323   }
39324
39325 }
39326
39327
39328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39329   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39330   Dali::Property::Index arg2 ;
39331   Dali::Property::Value arg3 ;
39332   Dali::Property::Value *argp3 ;
39333
39334   arg1 = (Dali::CustomActorImpl *)jarg1;
39335   arg2 = (Dali::Property::Index)jarg2;
39336   argp3 = (Dali::Property::Value *)jarg3;
39337   if (!argp3) {
39338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39339     return ;
39340   }
39341   arg3 = *argp3;
39342   {
39343     try {
39344       (arg1)->OnPropertySet(arg2,arg3);
39345     } catch (std::out_of_range& e) {
39346       {
39347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39348       };
39349     } catch (std::exception& e) {
39350       {
39351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39352       };
39353     } catch (Dali::DaliException e) {
39354       {
39355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39356       };
39357     } catch (...) {
39358       {
39359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39360       };
39361     }
39362   }
39363
39364 }
39365
39366
39367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39368   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39369   Dali::Vector3 *arg2 = 0 ;
39370
39371   arg1 = (Dali::CustomActorImpl *)jarg1;
39372   arg2 = (Dali::Vector3 *)jarg2;
39373   if (!arg2) {
39374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39375     return ;
39376   }
39377   {
39378     try {
39379       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39380     } catch (std::out_of_range& e) {
39381       {
39382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39383       };
39384     } catch (std::exception& e) {
39385       {
39386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39387       };
39388     } catch (Dali::DaliException e) {
39389       {
39390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39391       };
39392     } catch (...) {
39393       {
39394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39395       };
39396     }
39397   }
39398
39399 }
39400
39401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39402   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39403   Dali::Animation *arg2 = 0 ;
39404   Dali::Vector3 *arg3 = 0 ;
39405
39406   arg1 = (Dali::CustomActorImpl *)jarg1;
39407   arg2 = (Dali::Animation *)jarg2;
39408   if (!arg2) {
39409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39410     return ;
39411   }
39412   arg3 = (Dali::Vector3 *)jarg3;
39413   if (!arg3) {
39414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39415     return ;
39416   }
39417   {
39418     try {
39419       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39420     } catch (std::out_of_range& e) {
39421       {
39422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39423       };
39424     } catch (std::exception& e) {
39425       {
39426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39427       };
39428     } catch (Dali::DaliException e) {
39429       {
39430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39431       };
39432     } catch (...) {
39433       {
39434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39435       };
39436     }
39437   }
39438
39439 }
39440
39441
39442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39443   unsigned int jresult ;
39444   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39445   Dali::TouchEvent *arg2 = 0 ;
39446   bool result;
39447
39448   arg1 = (Dali::CustomActorImpl *)jarg1;
39449   arg2 = (Dali::TouchEvent *)jarg2;
39450   if (!arg2) {
39451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39452     return 0;
39453   }
39454   {
39455     try {
39456       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39457     } catch (std::out_of_range& e) {
39458       {
39459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39460       };
39461     } catch (std::exception& e) {
39462       {
39463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39464       };
39465     } catch (Dali::DaliException e) {
39466       {
39467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39468       };
39469     } catch (...) {
39470       {
39471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39472       };
39473     }
39474   }
39475
39476   jresult = result;
39477   return jresult;
39478 }
39479
39480
39481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39482   unsigned int jresult ;
39483   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39484   Dali::HoverEvent *arg2 = 0 ;
39485   bool result;
39486
39487   arg1 = (Dali::CustomActorImpl *)jarg1;
39488   arg2 = (Dali::HoverEvent *)jarg2;
39489   if (!arg2) {
39490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39491     return 0;
39492   }
39493   {
39494     try {
39495       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39496     } catch (std::out_of_range& e) {
39497       {
39498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39499       };
39500     } catch (std::exception& e) {
39501       {
39502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39503       };
39504     } catch (Dali::DaliException e) {
39505       {
39506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39507       };
39508     } catch (...) {
39509       {
39510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39511       };
39512     }
39513   }
39514
39515   jresult = result;
39516   return jresult;
39517 }
39518
39519
39520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39521   unsigned int jresult ;
39522   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39523   Dali::KeyEvent *arg2 = 0 ;
39524   bool result;
39525
39526   arg1 = (Dali::CustomActorImpl *)jarg1;
39527   arg2 = (Dali::KeyEvent *)jarg2;
39528   if (!arg2) {
39529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39530     return 0;
39531   }
39532   {
39533     try {
39534       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39535     } catch (std::out_of_range& e) {
39536       {
39537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39538       };
39539     } catch (std::exception& e) {
39540       {
39541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39542       };
39543     } catch (Dali::DaliException e) {
39544       {
39545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39546       };
39547     } catch (...) {
39548       {
39549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39550       };
39551     }
39552   }
39553
39554   jresult = result;
39555   return jresult;
39556 }
39557
39558
39559 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39560   unsigned int jresult ;
39561   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39562   Dali::WheelEvent *arg2 = 0 ;
39563   bool result;
39564
39565   arg1 = (Dali::CustomActorImpl *)jarg1;
39566   arg2 = (Dali::WheelEvent *)jarg2;
39567   if (!arg2) {
39568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39569     return 0;
39570   }
39571   {
39572     try {
39573       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39574     } catch (std::out_of_range& e) {
39575       {
39576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39577       };
39578     } catch (std::exception& e) {
39579       {
39580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39581       };
39582     } catch (Dali::DaliException e) {
39583       {
39584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39585       };
39586     } catch (...) {
39587       {
39588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39589       };
39590     }
39591   }
39592
39593   jresult = result;
39594   return jresult;
39595 }
39596
39597
39598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39599   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39600   Dali::Vector2 *arg2 = 0 ;
39601   Dali::RelayoutContainer *arg3 = 0 ;
39602
39603   arg1 = (Dali::CustomActorImpl *)jarg1;
39604   arg2 = (Dali::Vector2 *)jarg2;
39605   if (!arg2) {
39606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39607     return ;
39608   }
39609   arg3 = (Dali::RelayoutContainer *)jarg3;
39610   if (!arg3) {
39611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39612     return ;
39613   }
39614   {
39615     try {
39616       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39617     } catch (std::out_of_range& e) {
39618       {
39619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39620       };
39621     } catch (std::exception& e) {
39622       {
39623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39624       };
39625     } catch (Dali::DaliException e) {
39626       {
39627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39628       };
39629     } catch (...) {
39630       {
39631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39632       };
39633     }
39634   }
39635
39636 }
39637
39638
39639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39640   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39641   Dali::ResizePolicy::Type arg2 ;
39642   Dali::Dimension::Type arg3 ;
39643
39644   arg1 = (Dali::CustomActorImpl *)jarg1;
39645   arg2 = (Dali::ResizePolicy::Type)jarg2;
39646   arg3 = (Dali::Dimension::Type)jarg3;
39647   {
39648     try {
39649       (arg1)->OnSetResizePolicy(arg2,arg3);
39650     } catch (std::out_of_range& e) {
39651       {
39652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39653       };
39654     } catch (std::exception& e) {
39655       {
39656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39657       };
39658     } catch (Dali::DaliException e) {
39659       {
39660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39661       };
39662     } catch (...) {
39663       {
39664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39665       };
39666     }
39667   }
39668
39669 }
39670
39671
39672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39673   void * jresult ;
39674   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39675   Dali::Vector3 result;
39676
39677   arg1 = (Dali::CustomActorImpl *)jarg1;
39678   {
39679     try {
39680       result = (arg1)->GetNaturalSize();
39681     } catch (std::out_of_range& e) {
39682       {
39683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39684       };
39685     } catch (std::exception& e) {
39686       {
39687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39688       };
39689     } catch (Dali::DaliException e) {
39690       {
39691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39692       };
39693     } catch (...) {
39694       {
39695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39696       };
39697     }
39698   }
39699
39700   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39701   return jresult;
39702 }
39703
39704
39705 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39706   float jresult ;
39707   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39708   Dali::Actor *arg2 = 0 ;
39709   Dali::Dimension::Type arg3 ;
39710   float result;
39711
39712   arg1 = (Dali::CustomActorImpl *)jarg1;
39713   arg2 = (Dali::Actor *)jarg2;
39714   if (!arg2) {
39715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39716     return 0;
39717   }
39718   arg3 = (Dali::Dimension::Type)jarg3;
39719   {
39720     try {
39721       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39722     } catch (std::out_of_range& e) {
39723       {
39724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39725       };
39726     } catch (std::exception& e) {
39727       {
39728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39729       };
39730     } catch (Dali::DaliException e) {
39731       {
39732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39733       };
39734     } catch (...) {
39735       {
39736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39737       };
39738     }
39739   }
39740
39741   jresult = result;
39742   return jresult;
39743 }
39744
39745
39746 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39747   float jresult ;
39748   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39749   float arg2 ;
39750   float result;
39751
39752   arg1 = (Dali::CustomActorImpl *)jarg1;
39753   arg2 = (float)jarg2;
39754   {
39755     try {
39756       result = (float)(arg1)->GetHeightForWidth(arg2);
39757     } catch (std::out_of_range& e) {
39758       {
39759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39760       };
39761     } catch (std::exception& e) {
39762       {
39763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39764       };
39765     } catch (Dali::DaliException e) {
39766       {
39767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39768       };
39769     } catch (...) {
39770       {
39771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39772       };
39773     }
39774   }
39775
39776   jresult = result;
39777   return jresult;
39778 }
39779
39780
39781 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39782   float jresult ;
39783   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39784   float arg2 ;
39785   float result;
39786
39787   arg1 = (Dali::CustomActorImpl *)jarg1;
39788   arg2 = (float)jarg2;
39789   {
39790     try {
39791       result = (float)(arg1)->GetWidthForHeight(arg2);
39792     } catch (std::out_of_range& e) {
39793       {
39794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39795       };
39796     } catch (std::exception& e) {
39797       {
39798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39799       };
39800     } catch (Dali::DaliException e) {
39801       {
39802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39803       };
39804     } catch (...) {
39805       {
39806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39807       };
39808     }
39809   }
39810
39811   jresult = result;
39812   return jresult;
39813 }
39814
39815
39816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39817   unsigned int jresult ;
39818   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39819   Dali::Dimension::Type arg2 ;
39820   bool result;
39821
39822   arg1 = (Dali::CustomActorImpl *)jarg1;
39823   arg2 = (Dali::Dimension::Type)jarg2;
39824   {
39825     try {
39826       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39827     } catch (std::out_of_range& e) {
39828       {
39829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39830       };
39831     } catch (std::exception& e) {
39832       {
39833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39834       };
39835     } catch (Dali::DaliException e) {
39836       {
39837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39838       };
39839     } catch (...) {
39840       {
39841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39842       };
39843     }
39844   }
39845
39846   jresult = result;
39847   return jresult;
39848 }
39849
39850
39851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39852   unsigned int jresult ;
39853   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39854   bool result;
39855
39856   arg1 = (Dali::CustomActorImpl *)jarg1;
39857   {
39858     try {
39859       result = (bool)(arg1)->RelayoutDependentOnChildren();
39860     } catch (std::out_of_range& e) {
39861       {
39862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39863       };
39864     } catch (std::exception& e) {
39865       {
39866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39867       };
39868     } catch (Dali::DaliException e) {
39869       {
39870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39871       };
39872     } catch (...) {
39873       {
39874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39875       };
39876     }
39877   }
39878
39879   jresult = result;
39880   return jresult;
39881 }
39882
39883
39884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39885   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39886   Dali::Dimension::Type arg2 ;
39887
39888   arg1 = (Dali::CustomActorImpl *)jarg1;
39889   arg2 = (Dali::Dimension::Type)jarg2;
39890   {
39891     try {
39892       (arg1)->OnCalculateRelayoutSize(arg2);
39893     } catch (std::out_of_range& e) {
39894       {
39895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39896       };
39897     } catch (std::exception& e) {
39898       {
39899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39900       };
39901     } catch (Dali::DaliException e) {
39902       {
39903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39904       };
39905     } catch (...) {
39906       {
39907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39908       };
39909     }
39910   }
39911
39912 }
39913
39914
39915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39916   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39917   float arg2 ;
39918   Dali::Dimension::Type arg3 ;
39919
39920   arg1 = (Dali::CustomActorImpl *)jarg1;
39921   arg2 = (float)jarg2;
39922   arg3 = (Dali::Dimension::Type)jarg3;
39923   {
39924     try {
39925       (arg1)->OnLayoutNegotiated(arg2,arg3);
39926     } catch (std::out_of_range& e) {
39927       {
39928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39929       };
39930     } catch (std::exception& e) {
39931       {
39932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39933       };
39934     } catch (Dali::DaliException e) {
39935       {
39936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39937       };
39938     } catch (...) {
39939       {
39940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39941       };
39942     }
39943   }
39944
39945 }
39946
39947
39948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39949   unsigned int jresult ;
39950   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39951   bool result;
39952
39953   arg1 = (Dali::CustomActorImpl *)jarg1;
39954   {
39955     try {
39956       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39957     } catch (std::out_of_range& e) {
39958       {
39959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39960       };
39961     } catch (std::exception& e) {
39962       {
39963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39964       };
39965     } catch (Dali::DaliException e) {
39966       {
39967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39968       };
39969     } catch (...) {
39970       {
39971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39972       };
39973     }
39974   }
39975
39976   jresult = result;
39977   return jresult;
39978 }
39979
39980
39981 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39982   unsigned int jresult ;
39983   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39984   bool result;
39985
39986   arg1 = (Dali::CustomActorImpl *)jarg1;
39987   {
39988     try {
39989       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39990     } catch (std::out_of_range& e) {
39991       {
39992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39993       };
39994     } catch (std::exception& e) {
39995       {
39996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39997       };
39998     } catch (Dali::DaliException e) {
39999       {
40000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40001       };
40002     } catch (...) {
40003       {
40004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40005       };
40006     }
40007   }
40008
40009   jresult = result;
40010   return jresult;
40011 }
40012
40013
40014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40015   unsigned int jresult ;
40016   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40017   bool result;
40018
40019   arg1 = (Dali::CustomActorImpl *)jarg1;
40020   {
40021     try {
40022       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40023     } catch (std::out_of_range& e) {
40024       {
40025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40026       };
40027     } catch (std::exception& e) {
40028       {
40029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40030       };
40031     } catch (Dali::DaliException e) {
40032       {
40033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40034       };
40035     } catch (...) {
40036       {
40037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40038       };
40039     }
40040   }
40041
40042   jresult = result;
40043   return jresult;
40044 }
40045
40046
40047 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40048   unsigned int jresult ;
40049   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40050   bool result;
40051
40052   arg1 = (Dali::CustomActorImpl *)jarg1;
40053   {
40054     try {
40055       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40056     } catch (std::out_of_range& e) {
40057       {
40058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40059       };
40060     } catch (std::exception& e) {
40061       {
40062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40063       };
40064     } catch (Dali::DaliException e) {
40065       {
40066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40067       };
40068     } catch (...) {
40069       {
40070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40071       };
40072     }
40073   }
40074
40075   jresult = result;
40076   return jresult;
40077 }
40078
40079
40080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40081   void * jresult ;
40082   Dali::CustomActor *result = 0 ;
40083
40084   {
40085     try {
40086       result = (Dali::CustomActor *)new Dali::CustomActor();
40087     } catch (std::out_of_range& e) {
40088       {
40089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40090       };
40091     } catch (std::exception& e) {
40092       {
40093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40094       };
40095     } catch (Dali::DaliException e) {
40096       {
40097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40098       };
40099     } catch (...) {
40100       {
40101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40102       };
40103     }
40104   }
40105
40106   jresult = (void *)result;
40107   return jresult;
40108 }
40109
40110
40111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40112   void * jresult ;
40113   Dali::BaseHandle arg1 ;
40114   Dali::BaseHandle *argp1 ;
40115   Dali::CustomActor result;
40116
40117   argp1 = (Dali::BaseHandle *)jarg1;
40118   if (!argp1) {
40119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40120     return 0;
40121   }
40122   arg1 = *argp1;
40123   {
40124     try {
40125       result = Dali::CustomActor::DownCast(arg1);
40126     } catch (std::out_of_range& e) {
40127       {
40128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40129       };
40130     } catch (std::exception& e) {
40131       {
40132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40133       };
40134     } catch (Dali::DaliException e) {
40135       {
40136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40137       };
40138     } catch (...) {
40139       {
40140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40141       };
40142     }
40143   }
40144
40145   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40146   return jresult;
40147 }
40148
40149
40150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40151   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40152
40153   arg1 = (Dali::CustomActor *)jarg1;
40154   {
40155     try {
40156       delete arg1;
40157     } catch (std::out_of_range& e) {
40158       {
40159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40160       };
40161     } catch (std::exception& e) {
40162       {
40163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40164       };
40165     } catch (Dali::DaliException e) {
40166       {
40167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40168       };
40169     } catch (...) {
40170       {
40171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40172       };
40173     }
40174   }
40175
40176 }
40177
40178
40179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40180   void * jresult ;
40181   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40182   Dali::CustomActorImpl *result = 0 ;
40183
40184   arg1 = (Dali::CustomActor *)jarg1;
40185   {
40186     try {
40187       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40188     } catch (std::out_of_range& e) {
40189       {
40190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40191       };
40192     } catch (std::exception& e) {
40193       {
40194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40195       };
40196     } catch (Dali::DaliException e) {
40197       {
40198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40199       };
40200     } catch (...) {
40201       {
40202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40203       };
40204     }
40205   }
40206
40207   jresult = (void *)result;
40208   return jresult;
40209 }
40210
40211
40212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40213   void * jresult ;
40214   Dali::CustomActorImpl *arg1 = 0 ;
40215   Dali::CustomActor *result = 0 ;
40216
40217   arg1 = (Dali::CustomActorImpl *)jarg1;
40218   if (!arg1) {
40219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40220     return 0;
40221   }
40222   {
40223     try {
40224       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
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_2(void * jarg1) {
40250   void * jresult ;
40251   Dali::CustomActor *arg1 = 0 ;
40252   Dali::CustomActor *result = 0 ;
40253
40254   arg1 = (Dali::CustomActor *)jarg1;
40255   if (!arg1) {
40256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40257     return 0;
40258   }
40259   {
40260     try {
40261       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*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_CustomActor_Assign(void * jarg1, void * jarg2) {
40287   void * jresult ;
40288   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40289   Dali::CustomActor *arg2 = 0 ;
40290   Dali::CustomActor *result = 0 ;
40291
40292   arg1 = (Dali::CustomActor *)jarg1;
40293   arg2 = (Dali::CustomActor *)jarg2;
40294   if (!arg2) {
40295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40296     return 0;
40297   }
40298   {
40299     try {
40300       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40301     } catch (std::out_of_range& e) {
40302       {
40303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40304       };
40305     } catch (std::exception& e) {
40306       {
40307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40308       };
40309     } catch (Dali::DaliException e) {
40310       {
40311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40312       };
40313     } catch (...) {
40314       {
40315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40316       };
40317     }
40318   }
40319
40320   jresult = (void *)result;
40321   return jresult;
40322 }
40323
40324
40325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40326   int jresult ;
40327   int result;
40328
40329   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40330   jresult = (int)result;
40331   return jresult;
40332 }
40333
40334
40335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40336   int jresult ;
40337   int result;
40338
40339   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40340   jresult = (int)result;
40341   return jresult;
40342 }
40343
40344
40345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40346   int jresult ;
40347   int result;
40348
40349   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40350   jresult = (int)result;
40351   return jresult;
40352 }
40353
40354
40355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40356   int jresult ;
40357   int result;
40358
40359   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40360   jresult = (int)result;
40361   return jresult;
40362 }
40363
40364
40365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40366   int jresult ;
40367   int result;
40368
40369   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40370   jresult = (int)result;
40371   return jresult;
40372 }
40373
40374
40375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40376   int jresult ;
40377   int result;
40378
40379   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40380   jresult = (int)result;
40381   return jresult;
40382 }
40383
40384
40385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40386   int jresult ;
40387   int result;
40388
40389   result = (int)Dali::PanGestureDetector::Property::PANNING;
40390   jresult = (int)result;
40391   return jresult;
40392 }
40393
40394
40395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40396   void * jresult ;
40397   Dali::PanGestureDetector::Property *result = 0 ;
40398
40399   {
40400     try {
40401       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40402     } catch (std::out_of_range& e) {
40403       {
40404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40405       };
40406     } catch (std::exception& e) {
40407       {
40408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40409       };
40410     } catch (Dali::DaliException e) {
40411       {
40412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40413       };
40414     } catch (...) {
40415       {
40416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40417       };
40418     }
40419   }
40420
40421   jresult = (void *)result;
40422   return jresult;
40423 }
40424
40425
40426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40427   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40428
40429   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40430   {
40431     try {
40432       delete arg1;
40433     } catch (std::out_of_range& e) {
40434       {
40435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40436       };
40437     } catch (std::exception& e) {
40438       {
40439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40440       };
40441     } catch (Dali::DaliException e) {
40442       {
40443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40444       };
40445     } catch (...) {
40446       {
40447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40448       };
40449     }
40450   }
40451
40452 }
40453
40454
40455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40456   void * jresult ;
40457   Dali::Radian *result = 0 ;
40458
40459   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40460   jresult = (void *)result;
40461   return jresult;
40462 }
40463
40464
40465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40466   void * jresult ;
40467   Dali::Radian *result = 0 ;
40468
40469   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40470   jresult = (void *)result;
40471   return jresult;
40472 }
40473
40474
40475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40476   void * jresult ;
40477   Dali::Radian *result = 0 ;
40478
40479   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40480   jresult = (void *)result;
40481   return jresult;
40482 }
40483
40484
40485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40486   void * jresult ;
40487   Dali::Radian *result = 0 ;
40488
40489   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40490   jresult = (void *)result;
40491   return jresult;
40492 }
40493
40494
40495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40496   void * jresult ;
40497   Dali::Radian *result = 0 ;
40498
40499   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40500   jresult = (void *)result;
40501   return jresult;
40502 }
40503
40504
40505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40506   void * jresult ;
40507   Dali::Radian *result = 0 ;
40508
40509   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40510   jresult = (void *)result;
40511   return jresult;
40512 }
40513
40514
40515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40516   void * jresult ;
40517   Dali::Radian *result = 0 ;
40518
40519   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40520   jresult = (void *)result;
40521   return jresult;
40522 }
40523
40524
40525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40526   void * jresult ;
40527   Dali::PanGestureDetector *result = 0 ;
40528
40529   {
40530     try {
40531       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40532     } catch (std::out_of_range& e) {
40533       {
40534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40535       };
40536     } catch (std::exception& e) {
40537       {
40538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40539       };
40540     } catch (Dali::DaliException e) {
40541       {
40542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40543       };
40544     } catch (...) {
40545       {
40546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40547       };
40548     }
40549   }
40550
40551   jresult = (void *)result;
40552   return jresult;
40553 }
40554
40555
40556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40557   void * jresult ;
40558   Dali::PanGestureDetector result;
40559
40560   {
40561     try {
40562       result = Dali::PanGestureDetector::New();
40563     } catch (std::out_of_range& e) {
40564       {
40565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40566       };
40567     } catch (std::exception& e) {
40568       {
40569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40570       };
40571     } catch (Dali::DaliException e) {
40572       {
40573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40574       };
40575     } catch (...) {
40576       {
40577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40578       };
40579     }
40580   }
40581
40582   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40583   return jresult;
40584 }
40585
40586
40587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40588   void * jresult ;
40589   Dali::BaseHandle arg1 ;
40590   Dali::BaseHandle *argp1 ;
40591   Dali::PanGestureDetector result;
40592
40593   argp1 = (Dali::BaseHandle *)jarg1;
40594   if (!argp1) {
40595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40596     return 0;
40597   }
40598   arg1 = *argp1;
40599   {
40600     try {
40601       result = Dali::PanGestureDetector::DownCast(arg1);
40602     } catch (std::out_of_range& e) {
40603       {
40604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40605       };
40606     } catch (std::exception& e) {
40607       {
40608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40609       };
40610     } catch (Dali::DaliException e) {
40611       {
40612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40613       };
40614     } catch (...) {
40615       {
40616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40617       };
40618     }
40619   }
40620
40621   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40622   return jresult;
40623 }
40624
40625
40626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40627   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40628
40629   arg1 = (Dali::PanGestureDetector *)jarg1;
40630   {
40631     try {
40632       delete arg1;
40633     } catch (std::out_of_range& e) {
40634       {
40635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40636       };
40637     } catch (std::exception& e) {
40638       {
40639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40640       };
40641     } catch (Dali::DaliException e) {
40642       {
40643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40644       };
40645     } catch (...) {
40646       {
40647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40648       };
40649     }
40650   }
40651
40652 }
40653
40654
40655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40656   void * jresult ;
40657   Dali::PanGestureDetector *arg1 = 0 ;
40658   Dali::PanGestureDetector *result = 0 ;
40659
40660   arg1 = (Dali::PanGestureDetector *)jarg1;
40661   if (!arg1) {
40662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40663     return 0;
40664   }
40665   {
40666     try {
40667       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40668     } catch (std::out_of_range& e) {
40669       {
40670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40671       };
40672     } catch (std::exception& e) {
40673       {
40674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40675       };
40676     } catch (Dali::DaliException e) {
40677       {
40678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40679       };
40680     } catch (...) {
40681       {
40682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40683       };
40684     }
40685   }
40686
40687   jresult = (void *)result;
40688   return jresult;
40689 }
40690
40691
40692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40693   void * jresult ;
40694   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40695   Dali::PanGestureDetector *arg2 = 0 ;
40696   Dali::PanGestureDetector *result = 0 ;
40697
40698   arg1 = (Dali::PanGestureDetector *)jarg1;
40699   arg2 = (Dali::PanGestureDetector *)jarg2;
40700   if (!arg2) {
40701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40702     return 0;
40703   }
40704   {
40705     try {
40706       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40707     } catch (std::out_of_range& e) {
40708       {
40709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40710       };
40711     } catch (std::exception& e) {
40712       {
40713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40714       };
40715     } catch (Dali::DaliException e) {
40716       {
40717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40718       };
40719     } catch (...) {
40720       {
40721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40722       };
40723     }
40724   }
40725
40726   jresult = (void *)result;
40727   return jresult;
40728 }
40729
40730
40731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40732   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40733   unsigned int arg2 ;
40734
40735   arg1 = (Dali::PanGestureDetector *)jarg1;
40736   arg2 = (unsigned int)jarg2;
40737   {
40738     try {
40739       (arg1)->SetMinimumTouchesRequired(arg2);
40740     } catch (std::out_of_range& e) {
40741       {
40742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40743       };
40744     } catch (std::exception& e) {
40745       {
40746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40747       };
40748     } catch (Dali::DaliException e) {
40749       {
40750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40751       };
40752     } catch (...) {
40753       {
40754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40755       };
40756     }
40757   }
40758
40759 }
40760
40761
40762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40763   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40764   unsigned int arg2 ;
40765
40766   arg1 = (Dali::PanGestureDetector *)jarg1;
40767   arg2 = (unsigned int)jarg2;
40768   {
40769     try {
40770       (arg1)->SetMaximumTouchesRequired(arg2);
40771     } catch (std::out_of_range& e) {
40772       {
40773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40774       };
40775     } catch (std::exception& e) {
40776       {
40777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40778       };
40779     } catch (Dali::DaliException e) {
40780       {
40781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40782       };
40783     } catch (...) {
40784       {
40785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40786       };
40787     }
40788   }
40789
40790 }
40791
40792
40793 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40794   unsigned int jresult ;
40795   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40796   unsigned int result;
40797
40798   arg1 = (Dali::PanGestureDetector *)jarg1;
40799   {
40800     try {
40801       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40802     } catch (std::out_of_range& e) {
40803       {
40804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40805       };
40806     } catch (std::exception& e) {
40807       {
40808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40809       };
40810     } catch (Dali::DaliException e) {
40811       {
40812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40813       };
40814     } catch (...) {
40815       {
40816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40817       };
40818     }
40819   }
40820
40821   jresult = result;
40822   return jresult;
40823 }
40824
40825
40826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40827   unsigned int jresult ;
40828   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40829   unsigned int result;
40830
40831   arg1 = (Dali::PanGestureDetector *)jarg1;
40832   {
40833     try {
40834       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40835     } catch (std::out_of_range& e) {
40836       {
40837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40838       };
40839     } catch (std::exception& e) {
40840       {
40841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40842       };
40843     } catch (Dali::DaliException e) {
40844       {
40845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40846       };
40847     } catch (...) {
40848       {
40849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40850       };
40851     }
40852   }
40853
40854   jresult = result;
40855   return jresult;
40856 }
40857
40858
40859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40860   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40861   Dali::Radian arg2 ;
40862   Dali::Radian arg3 ;
40863   Dali::Radian *argp2 ;
40864   Dali::Radian *argp3 ;
40865
40866   arg1 = (Dali::PanGestureDetector *)jarg1;
40867   argp2 = (Dali::Radian *)jarg2;
40868   if (!argp2) {
40869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40870     return ;
40871   }
40872   arg2 = *argp2;
40873   argp3 = (Dali::Radian *)jarg3;
40874   if (!argp3) {
40875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40876     return ;
40877   }
40878   arg3 = *argp3;
40879   {
40880     try {
40881       (arg1)->AddAngle(arg2,arg3);
40882     } catch (std::out_of_range& e) {
40883       {
40884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40885       };
40886     } catch (std::exception& e) {
40887       {
40888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40889       };
40890     } catch (Dali::DaliException e) {
40891       {
40892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40893       };
40894     } catch (...) {
40895       {
40896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40897       };
40898     }
40899   }
40900
40901 }
40902
40903
40904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40905   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40906   Dali::Radian arg2 ;
40907   Dali::Radian *argp2 ;
40908
40909   arg1 = (Dali::PanGestureDetector *)jarg1;
40910   argp2 = (Dali::Radian *)jarg2;
40911   if (!argp2) {
40912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40913     return ;
40914   }
40915   arg2 = *argp2;
40916   {
40917     try {
40918       (arg1)->AddAngle(arg2);
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_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40942   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40943   Dali::Radian arg2 ;
40944   Dali::Radian arg3 ;
40945   Dali::Radian *argp2 ;
40946   Dali::Radian *argp3 ;
40947
40948   arg1 = (Dali::PanGestureDetector *)jarg1;
40949   argp2 = (Dali::Radian *)jarg2;
40950   if (!argp2) {
40951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40952     return ;
40953   }
40954   arg2 = *argp2;
40955   argp3 = (Dali::Radian *)jarg3;
40956   if (!argp3) {
40957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40958     return ;
40959   }
40960   arg3 = *argp3;
40961   {
40962     try {
40963       (arg1)->AddDirection(arg2,arg3);
40964     } catch (std::out_of_range& e) {
40965       {
40966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40967       };
40968     } catch (std::exception& e) {
40969       {
40970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40971       };
40972     } catch (Dali::DaliException e) {
40973       {
40974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40975       };
40976     } catch (...) {
40977       {
40978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40979       };
40980     }
40981   }
40982
40983 }
40984
40985
40986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40987   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40988   Dali::Radian arg2 ;
40989   Dali::Radian *argp2 ;
40990
40991   arg1 = (Dali::PanGestureDetector *)jarg1;
40992   argp2 = (Dali::Radian *)jarg2;
40993   if (!argp2) {
40994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40995     return ;
40996   }
40997   arg2 = *argp2;
40998   {
40999     try {
41000       (arg1)->AddDirection(arg2);
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 unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41024   unsigned long jresult ;
41025   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41026   size_t result;
41027
41028   arg1 = (Dali::PanGestureDetector *)jarg1;
41029   {
41030     try {
41031       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41032     } catch (std::out_of_range& e) {
41033       {
41034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41035       };
41036     } catch (std::exception& e) {
41037       {
41038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41039       };
41040     } catch (Dali::DaliException e) {
41041       {
41042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41043       };
41044     } catch (...) {
41045       {
41046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41047       };
41048     }
41049   }
41050
41051   jresult = (unsigned long)result;
41052   return jresult;
41053 }
41054
41055
41056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41057   void * jresult ;
41058   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41059   size_t arg2 ;
41060   Dali::PanGestureDetector::AngleThresholdPair result;
41061
41062   arg1 = (Dali::PanGestureDetector *)jarg1;
41063   arg2 = (size_t)jarg2;
41064   {
41065     try {
41066       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41067     } catch (std::out_of_range& e) {
41068       {
41069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41070       };
41071     } catch (std::exception& e) {
41072       {
41073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41074       };
41075     } catch (Dali::DaliException e) {
41076       {
41077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41078       };
41079     } catch (...) {
41080       {
41081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41082       };
41083     }
41084   }
41085
41086   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41087   return jresult;
41088 }
41089
41090
41091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41092   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41093
41094   arg1 = (Dali::PanGestureDetector *)jarg1;
41095   {
41096     try {
41097       (arg1)->ClearAngles();
41098     } catch (std::out_of_range& e) {
41099       {
41100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41101       };
41102     } catch (std::exception& e) {
41103       {
41104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41105       };
41106     } catch (Dali::DaliException e) {
41107       {
41108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41109       };
41110     } catch (...) {
41111       {
41112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41113       };
41114     }
41115   }
41116
41117 }
41118
41119
41120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41121   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41122   Dali::Radian arg2 ;
41123   Dali::Radian *argp2 ;
41124
41125   arg1 = (Dali::PanGestureDetector *)jarg1;
41126   argp2 = (Dali::Radian *)jarg2;
41127   if (!argp2) {
41128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41129     return ;
41130   }
41131   arg2 = *argp2;
41132   {
41133     try {
41134       (arg1)->RemoveAngle(arg2);
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_RemoveDirection(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)->RemoveDirection(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_DetectedSignal(void * jarg1) {
41195   void * jresult ;
41196   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41197   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41198
41199   arg1 = (Dali::PanGestureDetector *)jarg1;
41200   {
41201     try {
41202       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41203     } catch (std::out_of_range& e) {
41204       {
41205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41206       };
41207     } catch (std::exception& e) {
41208       {
41209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41210       };
41211     } catch (Dali::DaliException e) {
41212       {
41213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41214       };
41215     } catch (...) {
41216       {
41217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41218       };
41219     }
41220   }
41221
41222   jresult = (void *)result;
41223   return jresult;
41224 }
41225
41226
41227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41228   Dali::PanGesture *arg1 = 0 ;
41229
41230   arg1 = (Dali::PanGesture *)jarg1;
41231   if (!arg1) {
41232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41233     return ;
41234   }
41235   {
41236     try {
41237       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41238     } catch (std::out_of_range& e) {
41239       {
41240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41241       };
41242     } catch (std::exception& e) {
41243       {
41244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41245       };
41246     } catch (Dali::DaliException e) {
41247       {
41248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41249       };
41250     } catch (...) {
41251       {
41252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41253       };
41254     }
41255   }
41256
41257 }
41258
41259
41260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41261   void * jresult ;
41262   Dali::PanGesture *result = 0 ;
41263
41264   {
41265     try {
41266       result = (Dali::PanGesture *)new Dali::PanGesture();
41267     } catch (std::out_of_range& e) {
41268       {
41269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41270       };
41271     } catch (std::exception& e) {
41272       {
41273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41274       };
41275     } catch (Dali::DaliException e) {
41276       {
41277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41278       };
41279     } catch (...) {
41280       {
41281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41282       };
41283     }
41284   }
41285
41286   jresult = (void *)result;
41287   return jresult;
41288 }
41289
41290
41291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41292   void * jresult ;
41293   Dali::Gesture::State arg1 ;
41294   Dali::PanGesture *result = 0 ;
41295
41296   arg1 = (Dali::Gesture::State)jarg1;
41297   {
41298     try {
41299       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41300     } catch (std::out_of_range& e) {
41301       {
41302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41303       };
41304     } catch (std::exception& e) {
41305       {
41306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41307       };
41308     } catch (Dali::DaliException e) {
41309       {
41310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41311       };
41312     } catch (...) {
41313       {
41314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41315       };
41316     }
41317   }
41318
41319   jresult = (void *)result;
41320   return jresult;
41321 }
41322
41323
41324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41325   void * jresult ;
41326   Dali::PanGesture *arg1 = 0 ;
41327   Dali::PanGesture *result = 0 ;
41328
41329   arg1 = (Dali::PanGesture *)jarg1;
41330   if (!arg1) {
41331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41332     return 0;
41333   }
41334   {
41335     try {
41336       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*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_PanGesture_Assign(void * jarg1, void * jarg2) {
41362   void * jresult ;
41363   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41364   Dali::PanGesture *arg2 = 0 ;
41365   Dali::PanGesture *result = 0 ;
41366
41367   arg1 = (Dali::PanGesture *)jarg1;
41368   arg2 = (Dali::PanGesture *)jarg2;
41369   if (!arg2) {
41370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41371     return 0;
41372   }
41373   {
41374     try {
41375       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41376     } catch (std::out_of_range& e) {
41377       {
41378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41379       };
41380     } catch (std::exception& e) {
41381       {
41382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41383       };
41384     } catch (Dali::DaliException e) {
41385       {
41386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41387       };
41388     } catch (...) {
41389       {
41390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41391       };
41392     }
41393   }
41394
41395   jresult = (void *)result;
41396   return jresult;
41397 }
41398
41399
41400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41401   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41402
41403   arg1 = (Dali::PanGesture *)jarg1;
41404   {
41405     try {
41406       delete arg1;
41407     } catch (std::out_of_range& e) {
41408       {
41409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41410       };
41411     } catch (std::exception& e) {
41412       {
41413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41414       };
41415     } catch (Dali::DaliException e) {
41416       {
41417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41418       };
41419     } catch (...) {
41420       {
41421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41422       };
41423     }
41424   }
41425
41426 }
41427
41428
41429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41430   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41431   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41432
41433   arg1 = (Dali::PanGesture *)jarg1;
41434   arg2 = (Dali::Vector2 *)jarg2;
41435   if (arg1) (arg1)->velocity = *arg2;
41436 }
41437
41438
41439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41440   void * jresult ;
41441   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41442   Dali::Vector2 *result = 0 ;
41443
41444   arg1 = (Dali::PanGesture *)jarg1;
41445   result = (Dali::Vector2 *)& ((arg1)->velocity);
41446   jresult = (void *)result;
41447   return jresult;
41448 }
41449
41450
41451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41452   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41453   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41454
41455   arg1 = (Dali::PanGesture *)jarg1;
41456   arg2 = (Dali::Vector2 *)jarg2;
41457   if (arg1) (arg1)->displacement = *arg2;
41458 }
41459
41460
41461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41462   void * jresult ;
41463   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41464   Dali::Vector2 *result = 0 ;
41465
41466   arg1 = (Dali::PanGesture *)jarg1;
41467   result = (Dali::Vector2 *)& ((arg1)->displacement);
41468   jresult = (void *)result;
41469   return jresult;
41470 }
41471
41472
41473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41474   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41475   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41476
41477   arg1 = (Dali::PanGesture *)jarg1;
41478   arg2 = (Dali::Vector2 *)jarg2;
41479   if (arg1) (arg1)->position = *arg2;
41480 }
41481
41482
41483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41484   void * jresult ;
41485   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41486   Dali::Vector2 *result = 0 ;
41487
41488   arg1 = (Dali::PanGesture *)jarg1;
41489   result = (Dali::Vector2 *)& ((arg1)->position);
41490   jresult = (void *)result;
41491   return jresult;
41492 }
41493
41494
41495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41496   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41497   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41498
41499   arg1 = (Dali::PanGesture *)jarg1;
41500   arg2 = (Dali::Vector2 *)jarg2;
41501   if (arg1) (arg1)->screenVelocity = *arg2;
41502 }
41503
41504
41505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41506   void * jresult ;
41507   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41508   Dali::Vector2 *result = 0 ;
41509
41510   arg1 = (Dali::PanGesture *)jarg1;
41511   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41512   jresult = (void *)result;
41513   return jresult;
41514 }
41515
41516
41517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41518   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41519   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41520
41521   arg1 = (Dali::PanGesture *)jarg1;
41522   arg2 = (Dali::Vector2 *)jarg2;
41523   if (arg1) (arg1)->screenDisplacement = *arg2;
41524 }
41525
41526
41527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41528   void * jresult ;
41529   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41530   Dali::Vector2 *result = 0 ;
41531
41532   arg1 = (Dali::PanGesture *)jarg1;
41533   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41534   jresult = (void *)result;
41535   return jresult;
41536 }
41537
41538
41539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41540   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41541   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41542
41543   arg1 = (Dali::PanGesture *)jarg1;
41544   arg2 = (Dali::Vector2 *)jarg2;
41545   if (arg1) (arg1)->screenPosition = *arg2;
41546 }
41547
41548
41549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41550   void * jresult ;
41551   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41552   Dali::Vector2 *result = 0 ;
41553
41554   arg1 = (Dali::PanGesture *)jarg1;
41555   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41556   jresult = (void *)result;
41557   return jresult;
41558 }
41559
41560
41561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41562   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41563   unsigned int arg2 ;
41564
41565   arg1 = (Dali::PanGesture *)jarg1;
41566   arg2 = (unsigned int)jarg2;
41567   if (arg1) (arg1)->numberOfTouches = arg2;
41568 }
41569
41570
41571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41572   unsigned int jresult ;
41573   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41574   unsigned int result;
41575
41576   arg1 = (Dali::PanGesture *)jarg1;
41577   result = (unsigned int) ((arg1)->numberOfTouches);
41578   jresult = result;
41579   return jresult;
41580 }
41581
41582
41583 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41584   float jresult ;
41585   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41586   float result;
41587
41588   arg1 = (Dali::PanGesture *)jarg1;
41589   {
41590     try {
41591       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41592     } catch (std::out_of_range& e) {
41593       {
41594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41595       };
41596     } catch (std::exception& e) {
41597       {
41598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41599       };
41600     } catch (Dali::DaliException e) {
41601       {
41602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41603       };
41604     } catch (...) {
41605       {
41606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41607       };
41608     }
41609   }
41610
41611   jresult = result;
41612   return jresult;
41613 }
41614
41615
41616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41617   float jresult ;
41618   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41619   float result;
41620
41621   arg1 = (Dali::PanGesture *)jarg1;
41622   {
41623     try {
41624       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41625     } catch (std::out_of_range& e) {
41626       {
41627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41628       };
41629     } catch (std::exception& e) {
41630       {
41631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41632       };
41633     } catch (Dali::DaliException e) {
41634       {
41635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41636       };
41637     } catch (...) {
41638       {
41639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41640       };
41641     }
41642   }
41643
41644   jresult = result;
41645   return jresult;
41646 }
41647
41648
41649 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41650   float jresult ;
41651   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41652   float result;
41653
41654   arg1 = (Dali::PanGesture *)jarg1;
41655   {
41656     try {
41657       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41658     } catch (std::out_of_range& e) {
41659       {
41660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41661       };
41662     } catch (std::exception& e) {
41663       {
41664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41665       };
41666     } catch (Dali::DaliException e) {
41667       {
41668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41669       };
41670     } catch (...) {
41671       {
41672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41673       };
41674     }
41675   }
41676
41677   jresult = result;
41678   return jresult;
41679 }
41680
41681
41682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41683   float jresult ;
41684   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41685   float result;
41686
41687   arg1 = (Dali::PanGesture *)jarg1;
41688   {
41689     try {
41690       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41691     } catch (std::out_of_range& e) {
41692       {
41693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41694       };
41695     } catch (std::exception& e) {
41696       {
41697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41698       };
41699     } catch (Dali::DaliException e) {
41700       {
41701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41702       };
41703     } catch (...) {
41704       {
41705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41706       };
41707     }
41708   }
41709
41710   jresult = result;
41711   return jresult;
41712 }
41713
41714
41715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41716   void * jresult ;
41717   Dali::PinchGestureDetector *result = 0 ;
41718
41719   {
41720     try {
41721       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41722     } catch (std::out_of_range& e) {
41723       {
41724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41725       };
41726     } catch (std::exception& e) {
41727       {
41728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41729       };
41730     } catch (Dali::DaliException e) {
41731       {
41732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41733       };
41734     } catch (...) {
41735       {
41736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41737       };
41738     }
41739   }
41740
41741   jresult = (void *)result;
41742   return jresult;
41743 }
41744
41745
41746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41747   void * jresult ;
41748   Dali::PinchGestureDetector result;
41749
41750   {
41751     try {
41752       result = Dali::PinchGestureDetector::New();
41753     } catch (std::out_of_range& e) {
41754       {
41755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41756       };
41757     } catch (std::exception& e) {
41758       {
41759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41760       };
41761     } catch (Dali::DaliException e) {
41762       {
41763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41764       };
41765     } catch (...) {
41766       {
41767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41768       };
41769     }
41770   }
41771
41772   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41773   return jresult;
41774 }
41775
41776
41777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41778   void * jresult ;
41779   Dali::BaseHandle arg1 ;
41780   Dali::BaseHandle *argp1 ;
41781   Dali::PinchGestureDetector result;
41782
41783   argp1 = (Dali::BaseHandle *)jarg1;
41784   if (!argp1) {
41785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41786     return 0;
41787   }
41788   arg1 = *argp1;
41789   {
41790     try {
41791       result = Dali::PinchGestureDetector::DownCast(arg1);
41792     } catch (std::out_of_range& e) {
41793       {
41794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41795       };
41796     } catch (std::exception& e) {
41797       {
41798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41799       };
41800     } catch (Dali::DaliException e) {
41801       {
41802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41803       };
41804     } catch (...) {
41805       {
41806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41807       };
41808     }
41809   }
41810
41811   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41812   return jresult;
41813 }
41814
41815
41816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41817   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41818
41819   arg1 = (Dali::PinchGestureDetector *)jarg1;
41820   {
41821     try {
41822       delete arg1;
41823     } catch (std::out_of_range& e) {
41824       {
41825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41826       };
41827     } catch (std::exception& e) {
41828       {
41829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41830       };
41831     } catch (Dali::DaliException e) {
41832       {
41833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41834       };
41835     } catch (...) {
41836       {
41837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41838       };
41839     }
41840   }
41841
41842 }
41843
41844
41845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41846   void * jresult ;
41847   Dali::PinchGestureDetector *arg1 = 0 ;
41848   Dali::PinchGestureDetector *result = 0 ;
41849
41850   arg1 = (Dali::PinchGestureDetector *)jarg1;
41851   if (!arg1) {
41852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41853     return 0;
41854   }
41855   {
41856     try {
41857       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41858     } catch (std::out_of_range& e) {
41859       {
41860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41861       };
41862     } catch (std::exception& e) {
41863       {
41864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41865       };
41866     } catch (Dali::DaliException e) {
41867       {
41868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41869       };
41870     } catch (...) {
41871       {
41872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41873       };
41874     }
41875   }
41876
41877   jresult = (void *)result;
41878   return jresult;
41879 }
41880
41881
41882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41883   void * jresult ;
41884   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41885   Dali::PinchGestureDetector *arg2 = 0 ;
41886   Dali::PinchGestureDetector *result = 0 ;
41887
41888   arg1 = (Dali::PinchGestureDetector *)jarg1;
41889   arg2 = (Dali::PinchGestureDetector *)jarg2;
41890   if (!arg2) {
41891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41892     return 0;
41893   }
41894   {
41895     try {
41896       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41897     } catch (std::out_of_range& e) {
41898       {
41899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41900       };
41901     } catch (std::exception& e) {
41902       {
41903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41904       };
41905     } catch (Dali::DaliException e) {
41906       {
41907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41908       };
41909     } catch (...) {
41910       {
41911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41912       };
41913     }
41914   }
41915
41916   jresult = (void *)result;
41917   return jresult;
41918 }
41919
41920
41921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41922   void * jresult ;
41923   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41924   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41925
41926   arg1 = (Dali::PinchGestureDetector *)jarg1;
41927   {
41928     try {
41929       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41930     } catch (std::out_of_range& e) {
41931       {
41932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41933       };
41934     } catch (std::exception& e) {
41935       {
41936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41937       };
41938     } catch (Dali::DaliException e) {
41939       {
41940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41941       };
41942     } catch (...) {
41943       {
41944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41945       };
41946     }
41947   }
41948
41949   jresult = (void *)result;
41950   return jresult;
41951 }
41952
41953
41954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41955   void * jresult ;
41956   Dali::Gesture::State arg1 ;
41957   Dali::PinchGesture *result = 0 ;
41958
41959   arg1 = (Dali::Gesture::State)jarg1;
41960   {
41961     try {
41962       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41963     } catch (std::out_of_range& e) {
41964       {
41965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41966       };
41967     } catch (std::exception& e) {
41968       {
41969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41970       };
41971     } catch (Dali::DaliException e) {
41972       {
41973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41974       };
41975     } catch (...) {
41976       {
41977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41978       };
41979     }
41980   }
41981
41982   jresult = (void *)result;
41983   return jresult;
41984 }
41985
41986
41987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41988   void * jresult ;
41989   Dali::PinchGesture *arg1 = 0 ;
41990   Dali::PinchGesture *result = 0 ;
41991
41992   arg1 = (Dali::PinchGesture *)jarg1;
41993   if (!arg1) {
41994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41995     return 0;
41996   }
41997   {
41998     try {
41999       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*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_PinchGesture_Assign(void * jarg1, void * jarg2) {
42025   void * jresult ;
42026   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42027   Dali::PinchGesture *arg2 = 0 ;
42028   Dali::PinchGesture *result = 0 ;
42029
42030   arg1 = (Dali::PinchGesture *)jarg1;
42031   arg2 = (Dali::PinchGesture *)jarg2;
42032   if (!arg2) {
42033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42034     return 0;
42035   }
42036   {
42037     try {
42038       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42039     } catch (std::out_of_range& e) {
42040       {
42041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42042       };
42043     } catch (std::exception& e) {
42044       {
42045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42046       };
42047     } catch (Dali::DaliException e) {
42048       {
42049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42050       };
42051     } catch (...) {
42052       {
42053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42054       };
42055     }
42056   }
42057
42058   jresult = (void *)result;
42059   return jresult;
42060 }
42061
42062
42063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42064   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42065
42066   arg1 = (Dali::PinchGesture *)jarg1;
42067   {
42068     try {
42069       delete arg1;
42070     } catch (std::out_of_range& e) {
42071       {
42072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42073       };
42074     } catch (std::exception& e) {
42075       {
42076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42077       };
42078     } catch (Dali::DaliException e) {
42079       {
42080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42081       };
42082     } catch (...) {
42083       {
42084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42085       };
42086     }
42087   }
42088
42089 }
42090
42091
42092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42093   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42094   float arg2 ;
42095
42096   arg1 = (Dali::PinchGesture *)jarg1;
42097   arg2 = (float)jarg2;
42098   if (arg1) (arg1)->scale = arg2;
42099 }
42100
42101
42102 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42103   float jresult ;
42104   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42105   float result;
42106
42107   arg1 = (Dali::PinchGesture *)jarg1;
42108   result = (float) ((arg1)->scale);
42109   jresult = result;
42110   return jresult;
42111 }
42112
42113
42114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42115   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42116   float arg2 ;
42117
42118   arg1 = (Dali::PinchGesture *)jarg1;
42119   arg2 = (float)jarg2;
42120   if (arg1) (arg1)->speed = arg2;
42121 }
42122
42123
42124 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42125   float jresult ;
42126   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42127   float result;
42128
42129   arg1 = (Dali::PinchGesture *)jarg1;
42130   result = (float) ((arg1)->speed);
42131   jresult = result;
42132   return jresult;
42133 }
42134
42135
42136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42137   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42138   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42139
42140   arg1 = (Dali::PinchGesture *)jarg1;
42141   arg2 = (Dali::Vector2 *)jarg2;
42142   if (arg1) (arg1)->screenCenterPoint = *arg2;
42143 }
42144
42145
42146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42147   void * jresult ;
42148   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42149   Dali::Vector2 *result = 0 ;
42150
42151   arg1 = (Dali::PinchGesture *)jarg1;
42152   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42153   jresult = (void *)result;
42154   return jresult;
42155 }
42156
42157
42158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42159   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42160   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42161
42162   arg1 = (Dali::PinchGesture *)jarg1;
42163   arg2 = (Dali::Vector2 *)jarg2;
42164   if (arg1) (arg1)->localCenterPoint = *arg2;
42165 }
42166
42167
42168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42169   void * jresult ;
42170   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42171   Dali::Vector2 *result = 0 ;
42172
42173   arg1 = (Dali::PinchGesture *)jarg1;
42174   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42175   jresult = (void *)result;
42176   return jresult;
42177 }
42178
42179
42180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42181   void * jresult ;
42182   Dali::TapGestureDetector *result = 0 ;
42183
42184   {
42185     try {
42186       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42187     } catch (std::out_of_range& e) {
42188       {
42189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42190       };
42191     } catch (std::exception& e) {
42192       {
42193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42194       };
42195     } catch (Dali::DaliException e) {
42196       {
42197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42198       };
42199     } catch (...) {
42200       {
42201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42202       };
42203     }
42204   }
42205
42206   jresult = (void *)result;
42207   return jresult;
42208 }
42209
42210
42211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42212   void * jresult ;
42213   Dali::TapGestureDetector result;
42214
42215   {
42216     try {
42217       result = Dali::TapGestureDetector::New();
42218     } catch (std::out_of_range& e) {
42219       {
42220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42221       };
42222     } catch (std::exception& e) {
42223       {
42224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42225       };
42226     } catch (Dali::DaliException e) {
42227       {
42228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42229       };
42230     } catch (...) {
42231       {
42232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42233       };
42234     }
42235   }
42236
42237   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42238   return jresult;
42239 }
42240
42241
42242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42243   void * jresult ;
42244   unsigned int arg1 ;
42245   Dali::TapGestureDetector result;
42246
42247   arg1 = (unsigned int)jarg1;
42248   {
42249     try {
42250       result = Dali::TapGestureDetector::New(arg1);
42251     } catch (std::out_of_range& e) {
42252       {
42253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42254       };
42255     } catch (std::exception& e) {
42256       {
42257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42258       };
42259     } catch (Dali::DaliException e) {
42260       {
42261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42262       };
42263     } catch (...) {
42264       {
42265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42266       };
42267     }
42268   }
42269
42270   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42271   return jresult;
42272 }
42273
42274
42275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42276   void * jresult ;
42277   Dali::BaseHandle arg1 ;
42278   Dali::BaseHandle *argp1 ;
42279   Dali::TapGestureDetector result;
42280
42281   argp1 = (Dali::BaseHandle *)jarg1;
42282   if (!argp1) {
42283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42284     return 0;
42285   }
42286   arg1 = *argp1;
42287   {
42288     try {
42289       result = Dali::TapGestureDetector::DownCast(arg1);
42290     } catch (std::out_of_range& e) {
42291       {
42292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42293       };
42294     } catch (std::exception& e) {
42295       {
42296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42297       };
42298     } catch (Dali::DaliException e) {
42299       {
42300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42301       };
42302     } catch (...) {
42303       {
42304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42305       };
42306     }
42307   }
42308
42309   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42310   return jresult;
42311 }
42312
42313
42314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42315   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42316
42317   arg1 = (Dali::TapGestureDetector *)jarg1;
42318   {
42319     try {
42320       delete arg1;
42321     } catch (std::out_of_range& e) {
42322       {
42323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42324       };
42325     } catch (std::exception& e) {
42326       {
42327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42328       };
42329     } catch (Dali::DaliException e) {
42330       {
42331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42332       };
42333     } catch (...) {
42334       {
42335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42336       };
42337     }
42338   }
42339
42340 }
42341
42342
42343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42344   void * jresult ;
42345   Dali::TapGestureDetector *arg1 = 0 ;
42346   Dali::TapGestureDetector *result = 0 ;
42347
42348   arg1 = (Dali::TapGestureDetector *)jarg1;
42349   if (!arg1) {
42350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42351     return 0;
42352   }
42353   {
42354     try {
42355       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42356     } catch (std::out_of_range& e) {
42357       {
42358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42359       };
42360     } catch (std::exception& e) {
42361       {
42362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42363       };
42364     } catch (Dali::DaliException e) {
42365       {
42366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42367       };
42368     } catch (...) {
42369       {
42370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42371       };
42372     }
42373   }
42374
42375   jresult = (void *)result;
42376   return jresult;
42377 }
42378
42379
42380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42381   void * jresult ;
42382   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42383   Dali::TapGestureDetector *arg2 = 0 ;
42384   Dali::TapGestureDetector *result = 0 ;
42385
42386   arg1 = (Dali::TapGestureDetector *)jarg1;
42387   arg2 = (Dali::TapGestureDetector *)jarg2;
42388   if (!arg2) {
42389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42390     return 0;
42391   }
42392   {
42393     try {
42394       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42395     } catch (std::out_of_range& e) {
42396       {
42397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42398       };
42399     } catch (std::exception& e) {
42400       {
42401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42402       };
42403     } catch (Dali::DaliException e) {
42404       {
42405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42406       };
42407     } catch (...) {
42408       {
42409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42410       };
42411     }
42412   }
42413
42414   jresult = (void *)result;
42415   return jresult;
42416 }
42417
42418
42419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42420   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42421   unsigned int arg2 ;
42422
42423   arg1 = (Dali::TapGestureDetector *)jarg1;
42424   arg2 = (unsigned int)jarg2;
42425   {
42426     try {
42427       (arg1)->SetMinimumTapsRequired(arg2);
42428     } catch (std::out_of_range& e) {
42429       {
42430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42431       };
42432     } catch (std::exception& e) {
42433       {
42434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42435       };
42436     } catch (Dali::DaliException e) {
42437       {
42438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42439       };
42440     } catch (...) {
42441       {
42442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42443       };
42444     }
42445   }
42446
42447 }
42448
42449
42450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42451   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42452   unsigned int arg2 ;
42453
42454   arg1 = (Dali::TapGestureDetector *)jarg1;
42455   arg2 = (unsigned int)jarg2;
42456   {
42457     try {
42458       (arg1)->SetMaximumTapsRequired(arg2);
42459     } catch (std::out_of_range& e) {
42460       {
42461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42462       };
42463     } catch (std::exception& e) {
42464       {
42465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42466       };
42467     } catch (Dali::DaliException e) {
42468       {
42469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42470       };
42471     } catch (...) {
42472       {
42473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42474       };
42475     }
42476   }
42477
42478 }
42479
42480
42481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42482   unsigned int jresult ;
42483   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42484   unsigned int result;
42485
42486   arg1 = (Dali::TapGestureDetector *)jarg1;
42487   {
42488     try {
42489       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42490     } catch (std::out_of_range& e) {
42491       {
42492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42493       };
42494     } catch (std::exception& e) {
42495       {
42496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42497       };
42498     } catch (Dali::DaliException e) {
42499       {
42500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42501       };
42502     } catch (...) {
42503       {
42504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42505       };
42506     }
42507   }
42508
42509   jresult = result;
42510   return jresult;
42511 }
42512
42513
42514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42515   unsigned int jresult ;
42516   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42517   unsigned int result;
42518
42519   arg1 = (Dali::TapGestureDetector *)jarg1;
42520   {
42521     try {
42522       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42523     } catch (std::out_of_range& e) {
42524       {
42525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42526       };
42527     } catch (std::exception& e) {
42528       {
42529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42530       };
42531     } catch (Dali::DaliException e) {
42532       {
42533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42534       };
42535     } catch (...) {
42536       {
42537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42538       };
42539     }
42540   }
42541
42542   jresult = result;
42543   return jresult;
42544 }
42545
42546
42547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42548   void * jresult ;
42549   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42550   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42551
42552   arg1 = (Dali::TapGestureDetector *)jarg1;
42553   {
42554     try {
42555       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42556     } catch (std::out_of_range& e) {
42557       {
42558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42559       };
42560     } catch (std::exception& e) {
42561       {
42562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42563       };
42564     } catch (Dali::DaliException e) {
42565       {
42566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42567       };
42568     } catch (...) {
42569       {
42570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42571       };
42572     }
42573   }
42574
42575   jresult = (void *)result;
42576   return jresult;
42577 }
42578
42579
42580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42581   void * jresult ;
42582   Dali::TapGesture *result = 0 ;
42583
42584   {
42585     try {
42586       result = (Dali::TapGesture *)new Dali::TapGesture();
42587     } catch (std::out_of_range& e) {
42588       {
42589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42590       };
42591     } catch (std::exception& e) {
42592       {
42593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42594       };
42595     } catch (Dali::DaliException e) {
42596       {
42597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42598       };
42599     } catch (...) {
42600       {
42601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42602       };
42603     }
42604   }
42605
42606   jresult = (void *)result;
42607   return jresult;
42608 }
42609
42610
42611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42612   void * jresult ;
42613   Dali::TapGesture *arg1 = 0 ;
42614   Dali::TapGesture *result = 0 ;
42615
42616   arg1 = (Dali::TapGesture *)jarg1;
42617   if (!arg1) {
42618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42619     return 0;
42620   }
42621   {
42622     try {
42623       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
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_TapGesture_Assign(void * jarg1, void * jarg2) {
42649   void * jresult ;
42650   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42651   Dali::TapGesture *arg2 = 0 ;
42652   Dali::TapGesture *result = 0 ;
42653
42654   arg1 = (Dali::TapGesture *)jarg1;
42655   arg2 = (Dali::TapGesture *)jarg2;
42656   if (!arg2) {
42657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42658     return 0;
42659   }
42660   {
42661     try {
42662       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42663     } catch (std::out_of_range& e) {
42664       {
42665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42666       };
42667     } catch (std::exception& e) {
42668       {
42669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42670       };
42671     } catch (Dali::DaliException e) {
42672       {
42673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42674       };
42675     } catch (...) {
42676       {
42677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42678       };
42679     }
42680   }
42681
42682   jresult = (void *)result;
42683   return jresult;
42684 }
42685
42686
42687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42688   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42689
42690   arg1 = (Dali::TapGesture *)jarg1;
42691   {
42692     try {
42693       delete arg1;
42694     } catch (std::out_of_range& e) {
42695       {
42696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42697       };
42698     } catch (std::exception& e) {
42699       {
42700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42701       };
42702     } catch (Dali::DaliException e) {
42703       {
42704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42705       };
42706     } catch (...) {
42707       {
42708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42709       };
42710     }
42711   }
42712
42713 }
42714
42715
42716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42717   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42718   unsigned int arg2 ;
42719
42720   arg1 = (Dali::TapGesture *)jarg1;
42721   arg2 = (unsigned int)jarg2;
42722   if (arg1) (arg1)->numberOfTaps = arg2;
42723 }
42724
42725
42726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42727   unsigned int jresult ;
42728   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42729   unsigned int result;
42730
42731   arg1 = (Dali::TapGesture *)jarg1;
42732   result = (unsigned int) ((arg1)->numberOfTaps);
42733   jresult = result;
42734   return jresult;
42735 }
42736
42737
42738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42739   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42740   unsigned int arg2 ;
42741
42742   arg1 = (Dali::TapGesture *)jarg1;
42743   arg2 = (unsigned int)jarg2;
42744   if (arg1) (arg1)->numberOfTouches = arg2;
42745 }
42746
42747
42748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42749   unsigned int jresult ;
42750   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42751   unsigned int result;
42752
42753   arg1 = (Dali::TapGesture *)jarg1;
42754   result = (unsigned int) ((arg1)->numberOfTouches);
42755   jresult = result;
42756   return jresult;
42757 }
42758
42759
42760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42761   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42762   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42763
42764   arg1 = (Dali::TapGesture *)jarg1;
42765   arg2 = (Dali::Vector2 *)jarg2;
42766   if (arg1) (arg1)->screenPoint = *arg2;
42767 }
42768
42769
42770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42771   void * jresult ;
42772   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42773   Dali::Vector2 *result = 0 ;
42774
42775   arg1 = (Dali::TapGesture *)jarg1;
42776   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42777   jresult = (void *)result;
42778   return jresult;
42779 }
42780
42781
42782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42783   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42784   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42785
42786   arg1 = (Dali::TapGesture *)jarg1;
42787   arg2 = (Dali::Vector2 *)jarg2;
42788   if (arg1) (arg1)->localPoint = *arg2;
42789 }
42790
42791
42792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42793   void * jresult ;
42794   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42795   Dali::Vector2 *result = 0 ;
42796
42797   arg1 = (Dali::TapGesture *)jarg1;
42798   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42799   jresult = (void *)result;
42800   return jresult;
42801 }
42802
42803
42804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42805   void * jresult ;
42806   Dali::AlphaFunction *result = 0 ;
42807
42808   {
42809     try {
42810       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42811     } catch (std::out_of_range& e) {
42812       {
42813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42814       };
42815     } catch (std::exception& e) {
42816       {
42817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42818       };
42819     } catch (Dali::DaliException e) {
42820       {
42821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42822       };
42823     } catch (...) {
42824       {
42825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42826       };
42827     }
42828   }
42829
42830   jresult = (void *)result;
42831   return jresult;
42832 }
42833
42834
42835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42836   void * jresult ;
42837   Dali::AlphaFunction::BuiltinFunction arg1 ;
42838   Dali::AlphaFunction *result = 0 ;
42839
42840   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42841   {
42842     try {
42843       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42844     } catch (std::out_of_range& e) {
42845       {
42846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42847       };
42848     } catch (std::exception& e) {
42849       {
42850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42851       };
42852     } catch (Dali::DaliException e) {
42853       {
42854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42855       };
42856     } catch (...) {
42857       {
42858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42859       };
42860     }
42861   }
42862
42863   jresult = (void *)result;
42864   return jresult;
42865 }
42866
42867
42868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42869   void * jresult ;
42870   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42871   Dali::AlphaFunction *result = 0 ;
42872
42873   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42874   {
42875     try {
42876       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42877     } catch (std::out_of_range& e) {
42878       {
42879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42880       };
42881     } catch (std::exception& e) {
42882       {
42883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42884       };
42885     } catch (Dali::DaliException e) {
42886       {
42887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42888       };
42889     } catch (...) {
42890       {
42891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42892       };
42893     }
42894   }
42895
42896   jresult = (void *)result;
42897   return jresult;
42898 }
42899
42900
42901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42902   void * jresult ;
42903   Dali::Vector2 *arg1 = 0 ;
42904   Dali::Vector2 *arg2 = 0 ;
42905   Dali::AlphaFunction *result = 0 ;
42906
42907   arg1 = (Dali::Vector2 *)jarg1;
42908   if (!arg1) {
42909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42910     return 0;
42911   }
42912   arg2 = (Dali::Vector2 *)jarg2;
42913   if (!arg2) {
42914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42915     return 0;
42916   }
42917   {
42918     try {
42919       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42920     } catch (std::out_of_range& e) {
42921       {
42922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42923       };
42924     } catch (std::exception& e) {
42925       {
42926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42927       };
42928     } catch (Dali::DaliException e) {
42929       {
42930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42931       };
42932     } catch (...) {
42933       {
42934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42935       };
42936     }
42937   }
42938
42939   jresult = (void *)result;
42940   return jresult;
42941 }
42942
42943
42944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42945   void * jresult ;
42946   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42947   Dali::Vector4 result;
42948
42949   arg1 = (Dali::AlphaFunction *)jarg1;
42950   {
42951     try {
42952       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42953     } catch (std::out_of_range& e) {
42954       {
42955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42956       };
42957     } catch (std::exception& e) {
42958       {
42959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42960       };
42961     } catch (Dali::DaliException e) {
42962       {
42963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42964       };
42965     } catch (...) {
42966       {
42967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42968       };
42969     }
42970   }
42971
42972   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42973   return jresult;
42974 }
42975
42976
42977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42978   void * jresult ;
42979   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42980   Dali::AlphaFunctionPrototype result;
42981
42982   arg1 = (Dali::AlphaFunction *)jarg1;
42983   {
42984     try {
42985       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42986     } catch (std::out_of_range& e) {
42987       {
42988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42989       };
42990     } catch (std::exception& e) {
42991       {
42992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42993       };
42994     } catch (Dali::DaliException e) {
42995       {
42996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42997       };
42998     } catch (...) {
42999       {
43000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43001       };
43002     }
43003   }
43004
43005   jresult = (void *)result;
43006   return jresult;
43007 }
43008
43009
43010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43011   int jresult ;
43012   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43013   Dali::AlphaFunction::BuiltinFunction result;
43014
43015   arg1 = (Dali::AlphaFunction *)jarg1;
43016   {
43017     try {
43018       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43019     } catch (std::out_of_range& e) {
43020       {
43021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43022       };
43023     } catch (std::exception& e) {
43024       {
43025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43026       };
43027     } catch (Dali::DaliException e) {
43028       {
43029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43030       };
43031     } catch (...) {
43032       {
43033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43034       };
43035     }
43036   }
43037
43038   jresult = (int)result;
43039   return jresult;
43040 }
43041
43042
43043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43044   int jresult ;
43045   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43046   Dali::AlphaFunction::Mode result;
43047
43048   arg1 = (Dali::AlphaFunction *)jarg1;
43049   {
43050     try {
43051       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43052     } catch (std::out_of_range& e) {
43053       {
43054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43055       };
43056     } catch (std::exception& e) {
43057       {
43058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43059       };
43060     } catch (Dali::DaliException e) {
43061       {
43062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43063       };
43064     } catch (...) {
43065       {
43066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43067       };
43068     }
43069   }
43070
43071   jresult = (int)result;
43072   return jresult;
43073 }
43074
43075
43076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43077   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43078
43079   arg1 = (Dali::AlphaFunction *)jarg1;
43080   {
43081     try {
43082       delete arg1;
43083     } catch (std::out_of_range& e) {
43084       {
43085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43086       };
43087     } catch (std::exception& e) {
43088       {
43089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43090       };
43091     } catch (Dali::DaliException e) {
43092       {
43093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43094       };
43095     } catch (...) {
43096       {
43097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43098       };
43099     }
43100   }
43101
43102 }
43103
43104
43105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43106   void * jresult ;
43107   Dali::KeyFrames result;
43108
43109   {
43110     try {
43111       result = Dali::KeyFrames::New();
43112     } catch (std::out_of_range& e) {
43113       {
43114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43115       };
43116     } catch (std::exception& e) {
43117       {
43118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43119       };
43120     } catch (Dali::DaliException e) {
43121       {
43122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43123       };
43124     } catch (...) {
43125       {
43126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43127       };
43128     }
43129   }
43130
43131   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43132   return jresult;
43133 }
43134
43135
43136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43137   void * jresult ;
43138   Dali::BaseHandle arg1 ;
43139   Dali::BaseHandle *argp1 ;
43140   Dali::KeyFrames result;
43141
43142   argp1 = (Dali::BaseHandle *)jarg1;
43143   if (!argp1) {
43144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43145     return 0;
43146   }
43147   arg1 = *argp1;
43148   {
43149     try {
43150       result = Dali::KeyFrames::DownCast(arg1);
43151     } catch (std::out_of_range& e) {
43152       {
43153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43154       };
43155     } catch (std::exception& e) {
43156       {
43157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43158       };
43159     } catch (Dali::DaliException e) {
43160       {
43161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43162       };
43163     } catch (...) {
43164       {
43165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43166       };
43167     }
43168   }
43169
43170   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43171   return jresult;
43172 }
43173
43174
43175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43176   void * jresult ;
43177   Dali::KeyFrames *result = 0 ;
43178
43179   {
43180     try {
43181       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43182     } catch (std::out_of_range& e) {
43183       {
43184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43185       };
43186     } catch (std::exception& e) {
43187       {
43188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43189       };
43190     } catch (Dali::DaliException e) {
43191       {
43192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43193       };
43194     } catch (...) {
43195       {
43196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43197       };
43198     }
43199   }
43200
43201   jresult = (void *)result;
43202   return jresult;
43203 }
43204
43205
43206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43207   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43208
43209   arg1 = (Dali::KeyFrames *)jarg1;
43210   {
43211     try {
43212       delete arg1;
43213     } catch (std::out_of_range& e) {
43214       {
43215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43216       };
43217     } catch (std::exception& e) {
43218       {
43219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43220       };
43221     } catch (Dali::DaliException e) {
43222       {
43223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43224       };
43225     } catch (...) {
43226       {
43227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43228       };
43229     }
43230   }
43231
43232 }
43233
43234
43235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43236   void * jresult ;
43237   Dali::KeyFrames *arg1 = 0 ;
43238   Dali::KeyFrames *result = 0 ;
43239
43240   arg1 = (Dali::KeyFrames *)jarg1;
43241   if (!arg1) {
43242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43243     return 0;
43244   }
43245   {
43246     try {
43247       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43248     } catch (std::out_of_range& e) {
43249       {
43250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43251       };
43252     } catch (std::exception& e) {
43253       {
43254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43255       };
43256     } catch (Dali::DaliException e) {
43257       {
43258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43259       };
43260     } catch (...) {
43261       {
43262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43263       };
43264     }
43265   }
43266
43267   jresult = (void *)result;
43268   return jresult;
43269 }
43270
43271
43272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43273   void * jresult ;
43274   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43275   Dali::KeyFrames *arg2 = 0 ;
43276   Dali::KeyFrames *result = 0 ;
43277
43278   arg1 = (Dali::KeyFrames *)jarg1;
43279   arg2 = (Dali::KeyFrames *)jarg2;
43280   if (!arg2) {
43281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43282     return 0;
43283   }
43284   {
43285     try {
43286       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43287     } catch (std::out_of_range& e) {
43288       {
43289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43290       };
43291     } catch (std::exception& e) {
43292       {
43293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43294       };
43295     } catch (Dali::DaliException e) {
43296       {
43297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43298       };
43299     } catch (...) {
43300       {
43301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43302       };
43303     }
43304   }
43305
43306   jresult = (void *)result;
43307   return jresult;
43308 }
43309
43310
43311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43312   int jresult ;
43313   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43314   Dali::Property::Type result;
43315
43316   arg1 = (Dali::KeyFrames *)jarg1;
43317   {
43318     try {
43319       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43320     } catch (std::out_of_range& e) {
43321       {
43322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43323       };
43324     } catch (std::exception& e) {
43325       {
43326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43327       };
43328     } catch (Dali::DaliException e) {
43329       {
43330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43331       };
43332     } catch (...) {
43333       {
43334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43335       };
43336     }
43337   }
43338
43339   jresult = (int)result;
43340   return jresult;
43341 }
43342
43343
43344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43345   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43346   float arg2 ;
43347   Dali::Property::Value arg3 ;
43348   Dali::Property::Value *argp3 ;
43349
43350   arg1 = (Dali::KeyFrames *)jarg1;
43351   arg2 = (float)jarg2;
43352   argp3 = (Dali::Property::Value *)jarg3;
43353   if (!argp3) {
43354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43355     return ;
43356   }
43357   arg3 = *argp3;
43358   {
43359     try {
43360       (arg1)->Add(arg2,arg3);
43361     } catch (std::out_of_range& e) {
43362       {
43363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43364       };
43365     } catch (std::exception& e) {
43366       {
43367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43368       };
43369     } catch (Dali::DaliException e) {
43370       {
43371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43372       };
43373     } catch (...) {
43374       {
43375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43376       };
43377     }
43378   }
43379
43380 }
43381
43382
43383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43384   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43385   float arg2 ;
43386   Dali::Property::Value arg3 ;
43387   Dali::AlphaFunction arg4 ;
43388   Dali::Property::Value *argp3 ;
43389   Dali::AlphaFunction *argp4 ;
43390
43391   arg1 = (Dali::KeyFrames *)jarg1;
43392   arg2 = (float)jarg2;
43393   argp3 = (Dali::Property::Value *)jarg3;
43394   if (!argp3) {
43395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43396     return ;
43397   }
43398   arg3 = *argp3;
43399   argp4 = (Dali::AlphaFunction *)jarg4;
43400   if (!argp4) {
43401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43402     return ;
43403   }
43404   arg4 = *argp4;
43405   {
43406     try {
43407       (arg1)->Add(arg2,arg3,arg4);
43408     } catch (std::out_of_range& e) {
43409       {
43410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43411       };
43412     } catch (std::exception& e) {
43413       {
43414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43415       };
43416     } catch (Dali::DaliException e) {
43417       {
43418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43419       };
43420     } catch (...) {
43421       {
43422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43423       };
43424     }
43425   }
43426
43427 }
43428
43429
43430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43431   int jresult ;
43432   int result;
43433
43434   result = (int)Dali::Path::Property::POINTS;
43435   jresult = (int)result;
43436   return jresult;
43437 }
43438
43439
43440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43441   int jresult ;
43442   int result;
43443
43444   result = (int)Dali::Path::Property::CONTROL_POINTS;
43445   jresult = (int)result;
43446   return jresult;
43447 }
43448
43449
43450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43451   void * jresult ;
43452   Dali::Path::Property *result = 0 ;
43453
43454   {
43455     try {
43456       result = (Dali::Path::Property *)new Dali::Path::Property();
43457     } catch (std::out_of_range& e) {
43458       {
43459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43460       };
43461     } catch (std::exception& e) {
43462       {
43463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43464       };
43465     } catch (Dali::DaliException e) {
43466       {
43467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43468       };
43469     } catch (...) {
43470       {
43471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43472       };
43473     }
43474   }
43475
43476   jresult = (void *)result;
43477   return jresult;
43478 }
43479
43480
43481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43482   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43483
43484   arg1 = (Dali::Path::Property *)jarg1;
43485   {
43486     try {
43487       delete arg1;
43488     } catch (std::out_of_range& e) {
43489       {
43490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43491       };
43492     } catch (std::exception& e) {
43493       {
43494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43495       };
43496     } catch (Dali::DaliException e) {
43497       {
43498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43499       };
43500     } catch (...) {
43501       {
43502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43503       };
43504     }
43505   }
43506
43507 }
43508
43509
43510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43511   void * jresult ;
43512   Dali::Path result;
43513
43514   {
43515     try {
43516       result = Dali::Path::New();
43517     } catch (std::out_of_range& e) {
43518       {
43519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43520       };
43521     } catch (std::exception& e) {
43522       {
43523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43524       };
43525     } catch (Dali::DaliException e) {
43526       {
43527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43528       };
43529     } catch (...) {
43530       {
43531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43532       };
43533     }
43534   }
43535
43536   jresult = new Dali::Path((const Dali::Path &)result);
43537   return jresult;
43538 }
43539
43540
43541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43542   void * jresult ;
43543   Dali::BaseHandle arg1 ;
43544   Dali::BaseHandle *argp1 ;
43545   Dali::Path result;
43546
43547   argp1 = (Dali::BaseHandle *)jarg1;
43548   if (!argp1) {
43549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43550     return 0;
43551   }
43552   arg1 = *argp1;
43553   {
43554     try {
43555       result = Dali::Path::DownCast(arg1);
43556     } catch (std::out_of_range& e) {
43557       {
43558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43559       };
43560     } catch (std::exception& e) {
43561       {
43562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43563       };
43564     } catch (Dali::DaliException e) {
43565       {
43566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43567       };
43568     } catch (...) {
43569       {
43570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43571       };
43572     }
43573   }
43574
43575   jresult = new Dali::Path((const Dali::Path &)result);
43576   return jresult;
43577 }
43578
43579
43580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43581   void * jresult ;
43582   Dali::Path *result = 0 ;
43583
43584   {
43585     try {
43586       result = (Dali::Path *)new Dali::Path();
43587     } catch (std::out_of_range& e) {
43588       {
43589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43590       };
43591     } catch (std::exception& e) {
43592       {
43593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43594       };
43595     } catch (Dali::DaliException e) {
43596       {
43597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43598       };
43599     } catch (...) {
43600       {
43601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43602       };
43603     }
43604   }
43605
43606   jresult = (void *)result;
43607   return jresult;
43608 }
43609
43610
43611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43612   Dali::Path *arg1 = (Dali::Path *) 0 ;
43613
43614   arg1 = (Dali::Path *)jarg1;
43615   {
43616     try {
43617       delete arg1;
43618     } catch (std::out_of_range& e) {
43619       {
43620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43621       };
43622     } catch (std::exception& e) {
43623       {
43624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43625       };
43626     } catch (Dali::DaliException e) {
43627       {
43628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43629       };
43630     } catch (...) {
43631       {
43632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43633       };
43634     }
43635   }
43636
43637 }
43638
43639
43640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43641   void * jresult ;
43642   Dali::Path *arg1 = 0 ;
43643   Dali::Path *result = 0 ;
43644
43645   arg1 = (Dali::Path *)jarg1;
43646   if (!arg1) {
43647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43648     return 0;
43649   }
43650   {
43651     try {
43652       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43653     } catch (std::out_of_range& e) {
43654       {
43655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43656       };
43657     } catch (std::exception& e) {
43658       {
43659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43660       };
43661     } catch (Dali::DaliException e) {
43662       {
43663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43664       };
43665     } catch (...) {
43666       {
43667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43668       };
43669     }
43670   }
43671
43672   jresult = (void *)result;
43673   return jresult;
43674 }
43675
43676
43677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43678   void * jresult ;
43679   Dali::Path *arg1 = (Dali::Path *) 0 ;
43680   Dali::Path *arg2 = 0 ;
43681   Dali::Path *result = 0 ;
43682
43683   arg1 = (Dali::Path *)jarg1;
43684   arg2 = (Dali::Path *)jarg2;
43685   if (!arg2) {
43686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43687     return 0;
43688   }
43689   {
43690     try {
43691       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43692     } catch (std::out_of_range& e) {
43693       {
43694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43695       };
43696     } catch (std::exception& e) {
43697       {
43698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43699       };
43700     } catch (Dali::DaliException e) {
43701       {
43702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43703       };
43704     } catch (...) {
43705       {
43706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43707       };
43708     }
43709   }
43710
43711   jresult = (void *)result;
43712   return jresult;
43713 }
43714
43715
43716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43717   Dali::Path *arg1 = (Dali::Path *) 0 ;
43718   Dali::Vector3 *arg2 = 0 ;
43719
43720   arg1 = (Dali::Path *)jarg1;
43721   arg2 = (Dali::Vector3 *)jarg2;
43722   if (!arg2) {
43723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43724     return ;
43725   }
43726   {
43727     try {
43728       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43729     } catch (std::out_of_range& e) {
43730       {
43731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43732       };
43733     } catch (std::exception& e) {
43734       {
43735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43736       };
43737     } catch (Dali::DaliException e) {
43738       {
43739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43740       };
43741     } catch (...) {
43742       {
43743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43744       };
43745     }
43746   }
43747
43748 }
43749
43750
43751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43752   Dali::Path *arg1 = (Dali::Path *) 0 ;
43753   Dali::Vector3 *arg2 = 0 ;
43754
43755   arg1 = (Dali::Path *)jarg1;
43756   arg2 = (Dali::Vector3 *)jarg2;
43757   if (!arg2) {
43758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43759     return ;
43760   }
43761   {
43762     try {
43763       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43764     } catch (std::out_of_range& e) {
43765       {
43766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43767       };
43768     } catch (std::exception& e) {
43769       {
43770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43771       };
43772     } catch (Dali::DaliException e) {
43773       {
43774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43775       };
43776     } catch (...) {
43777       {
43778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43779       };
43780     }
43781   }
43782
43783 }
43784
43785
43786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43787   Dali::Path *arg1 = (Dali::Path *) 0 ;
43788   float arg2 ;
43789
43790   arg1 = (Dali::Path *)jarg1;
43791   arg2 = (float)jarg2;
43792   {
43793     try {
43794       (arg1)->GenerateControlPoints(arg2);
43795     } catch (std::out_of_range& e) {
43796       {
43797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43798       };
43799     } catch (std::exception& e) {
43800       {
43801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43802       };
43803     } catch (Dali::DaliException e) {
43804       {
43805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43806       };
43807     } catch (...) {
43808       {
43809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43810       };
43811     }
43812   }
43813
43814 }
43815
43816
43817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43818   Dali::Path *arg1 = (Dali::Path *) 0 ;
43819   float arg2 ;
43820   Dali::Vector3 *arg3 = 0 ;
43821   Dali::Vector3 *arg4 = 0 ;
43822
43823   arg1 = (Dali::Path *)jarg1;
43824   arg2 = (float)jarg2;
43825   arg3 = (Dali::Vector3 *)jarg3;
43826   if (!arg3) {
43827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43828     return ;
43829   }
43830   arg4 = (Dali::Vector3 *)jarg4;
43831   if (!arg4) {
43832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43833     return ;
43834   }
43835   {
43836     try {
43837       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43838     } catch (std::out_of_range& e) {
43839       {
43840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43841       };
43842     } catch (std::exception& e) {
43843       {
43844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43845       };
43846     } catch (Dali::DaliException e) {
43847       {
43848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43849       };
43850     } catch (...) {
43851       {
43852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43853       };
43854     }
43855   }
43856
43857 }
43858
43859
43860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43861   void * jresult ;
43862   Dali::Path *arg1 = (Dali::Path *) 0 ;
43863   size_t arg2 ;
43864   Dali::Vector3 *result = 0 ;
43865
43866   arg1 = (Dali::Path *)jarg1;
43867   arg2 = (size_t)jarg2;
43868   {
43869     try {
43870       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43871     } catch (std::out_of_range& e) {
43872       {
43873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43874       };
43875     } catch (std::exception& e) {
43876       {
43877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43878       };
43879     } catch (Dali::DaliException e) {
43880       {
43881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43882       };
43883     } catch (...) {
43884       {
43885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43886       };
43887     }
43888   }
43889
43890   jresult = (void *)result;
43891   return jresult;
43892 }
43893
43894
43895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43896   void * jresult ;
43897   Dali::Path *arg1 = (Dali::Path *) 0 ;
43898   size_t arg2 ;
43899   Dali::Vector3 *result = 0 ;
43900
43901   arg1 = (Dali::Path *)jarg1;
43902   arg2 = (size_t)jarg2;
43903   {
43904     try {
43905       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43906     } catch (std::out_of_range& e) {
43907       {
43908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43909       };
43910     } catch (std::exception& e) {
43911       {
43912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43913       };
43914     } catch (Dali::DaliException e) {
43915       {
43916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43917       };
43918     } catch (...) {
43919       {
43920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43921       };
43922     }
43923   }
43924
43925   jresult = (void *)result;
43926   return jresult;
43927 }
43928
43929
43930 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43931   unsigned long jresult ;
43932   Dali::Path *arg1 = (Dali::Path *) 0 ;
43933   size_t result;
43934
43935   arg1 = (Dali::Path *)jarg1;
43936   {
43937     try {
43938       result = ((Dali::Path const *)arg1)->GetPointCount();
43939     } catch (std::out_of_range& e) {
43940       {
43941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43942       };
43943     } catch (std::exception& e) {
43944       {
43945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43946       };
43947     } catch (Dali::DaliException e) {
43948       {
43949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43950       };
43951     } catch (...) {
43952       {
43953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43954       };
43955     }
43956   }
43957
43958   jresult = (unsigned long)result;
43959   return jresult;
43960 }
43961
43962
43963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43964   void * jresult ;
43965   float arg1 ;
43966   Dali::TimePeriod *result = 0 ;
43967
43968   arg1 = (float)jarg1;
43969   {
43970     try {
43971       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43972     } catch (std::out_of_range& e) {
43973       {
43974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43975       };
43976     } catch (std::exception& e) {
43977       {
43978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43979       };
43980     } catch (Dali::DaliException e) {
43981       {
43982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43983       };
43984     } catch (...) {
43985       {
43986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43987       };
43988     }
43989   }
43990
43991   jresult = (void *)result;
43992   return jresult;
43993 }
43994
43995
43996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43997   void * jresult ;
43998   float arg1 ;
43999   float arg2 ;
44000   Dali::TimePeriod *result = 0 ;
44001
44002   arg1 = (float)jarg1;
44003   arg2 = (float)jarg2;
44004   {
44005     try {
44006       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44007     } catch (std::out_of_range& e) {
44008       {
44009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44010       };
44011     } catch (std::exception& e) {
44012       {
44013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44014       };
44015     } catch (Dali::DaliException e) {
44016       {
44017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44018       };
44019     } catch (...) {
44020       {
44021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44022       };
44023     }
44024   }
44025
44026   jresult = (void *)result;
44027   return jresult;
44028 }
44029
44030
44031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44032   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44033
44034   arg1 = (Dali::TimePeriod *)jarg1;
44035   {
44036     try {
44037       delete arg1;
44038     } catch (std::out_of_range& e) {
44039       {
44040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44041       };
44042     } catch (std::exception& e) {
44043       {
44044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44045       };
44046     } catch (Dali::DaliException e) {
44047       {
44048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44049       };
44050     } catch (...) {
44051       {
44052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44053       };
44054     }
44055   }
44056
44057 }
44058
44059
44060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44061   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44062   float arg2 ;
44063
44064   arg1 = (Dali::TimePeriod *)jarg1;
44065   arg2 = (float)jarg2;
44066   if (arg1) (arg1)->delaySeconds = arg2;
44067 }
44068
44069
44070 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44071   float jresult ;
44072   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44073   float result;
44074
44075   arg1 = (Dali::TimePeriod *)jarg1;
44076   result = (float) ((arg1)->delaySeconds);
44077   jresult = result;
44078   return jresult;
44079 }
44080
44081
44082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44083   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44084   float arg2 ;
44085
44086   arg1 = (Dali::TimePeriod *)jarg1;
44087   arg2 = (float)jarg2;
44088   if (arg1) (arg1)->durationSeconds = arg2;
44089 }
44090
44091
44092 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44093   float jresult ;
44094   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44095   float result;
44096
44097   arg1 = (Dali::TimePeriod *)jarg1;
44098   result = (float) ((arg1)->durationSeconds);
44099   jresult = result;
44100   return jresult;
44101 }
44102
44103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44104   int jresult ;
44105   int result;
44106
44107   result = (int)Dali::LinearConstrainer::Property::VALUE;
44108   jresult = (int)result;
44109   return jresult;
44110 }
44111
44112
44113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44114   int jresult ;
44115   int result;
44116
44117   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44118   jresult = (int)result;
44119   return jresult;
44120 }
44121
44122
44123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44124   void * jresult ;
44125   Dali::LinearConstrainer::Property *result = 0 ;
44126
44127   {
44128     try {
44129       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44130     } catch (std::out_of_range& e) {
44131       {
44132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44133       };
44134     } catch (std::exception& e) {
44135       {
44136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44137       };
44138     } catch (Dali::DaliException e) {
44139       {
44140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44141       };
44142     } catch (...) {
44143       {
44144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44145       };
44146     }
44147   }
44148
44149   jresult = (void *)result;
44150   return jresult;
44151 }
44152
44153
44154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44155   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44156
44157   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44158   {
44159     try {
44160       delete arg1;
44161     } catch (std::out_of_range& e) {
44162       {
44163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44164       };
44165     } catch (std::exception& e) {
44166       {
44167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44168       };
44169     } catch (Dali::DaliException e) {
44170       {
44171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44172       };
44173     } catch (...) {
44174       {
44175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44176       };
44177     }
44178   }
44179
44180 }
44181
44182
44183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44184   void * jresult ;
44185   Dali::LinearConstrainer result;
44186
44187   {
44188     try {
44189       result = Dali::LinearConstrainer::New();
44190     } catch (std::out_of_range& e) {
44191       {
44192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44193       };
44194     } catch (std::exception& e) {
44195       {
44196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44197       };
44198     } catch (Dali::DaliException e) {
44199       {
44200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44201       };
44202     } catch (...) {
44203       {
44204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44205       };
44206     }
44207   }
44208
44209   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44210   return jresult;
44211 }
44212
44213
44214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44215   void * jresult ;
44216   Dali::BaseHandle arg1 ;
44217   Dali::BaseHandle *argp1 ;
44218   Dali::LinearConstrainer result;
44219
44220   argp1 = (Dali::BaseHandle *)jarg1;
44221   if (!argp1) {
44222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44223     return 0;
44224   }
44225   arg1 = *argp1;
44226   {
44227     try {
44228       result = Dali::LinearConstrainer::DownCast(arg1);
44229     } catch (std::out_of_range& e) {
44230       {
44231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44232       };
44233     } catch (std::exception& e) {
44234       {
44235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44236       };
44237     } catch (Dali::DaliException e) {
44238       {
44239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44240       };
44241     } catch (...) {
44242       {
44243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44244       };
44245     }
44246   }
44247
44248   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44249   return jresult;
44250 }
44251
44252
44253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44254   void * jresult ;
44255   Dali::LinearConstrainer *result = 0 ;
44256
44257   {
44258     try {
44259       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44260     } catch (std::out_of_range& e) {
44261       {
44262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44263       };
44264     } catch (std::exception& e) {
44265       {
44266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44267       };
44268     } catch (Dali::DaliException e) {
44269       {
44270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44271       };
44272     } catch (...) {
44273       {
44274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44275       };
44276     }
44277   }
44278
44279   jresult = (void *)result;
44280   return jresult;
44281 }
44282
44283
44284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44285   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44286
44287   arg1 = (Dali::LinearConstrainer *)jarg1;
44288   {
44289     try {
44290       delete arg1;
44291     } catch (std::out_of_range& e) {
44292       {
44293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44294       };
44295     } catch (std::exception& e) {
44296       {
44297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44298       };
44299     } catch (Dali::DaliException e) {
44300       {
44301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44302       };
44303     } catch (...) {
44304       {
44305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44306       };
44307     }
44308   }
44309
44310 }
44311
44312
44313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44314   void * jresult ;
44315   Dali::LinearConstrainer *arg1 = 0 ;
44316   Dali::LinearConstrainer *result = 0 ;
44317
44318   arg1 = (Dali::LinearConstrainer *)jarg1;
44319   if (!arg1) {
44320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44321     return 0;
44322   }
44323   {
44324     try {
44325       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44326     } catch (std::out_of_range& e) {
44327       {
44328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44329       };
44330     } catch (std::exception& e) {
44331       {
44332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44333       };
44334     } catch (Dali::DaliException e) {
44335       {
44336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44337       };
44338     } catch (...) {
44339       {
44340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44341       };
44342     }
44343   }
44344
44345   jresult = (void *)result;
44346   return jresult;
44347 }
44348
44349
44350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44351   void * jresult ;
44352   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44353   Dali::LinearConstrainer *arg2 = 0 ;
44354   Dali::LinearConstrainer *result = 0 ;
44355
44356   arg1 = (Dali::LinearConstrainer *)jarg1;
44357   arg2 = (Dali::LinearConstrainer *)jarg2;
44358   if (!arg2) {
44359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44360     return 0;
44361   }
44362   {
44363     try {
44364       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44365     } catch (std::out_of_range& e) {
44366       {
44367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44368       };
44369     } catch (std::exception& e) {
44370       {
44371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44372       };
44373     } catch (Dali::DaliException e) {
44374       {
44375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44376       };
44377     } catch (...) {
44378       {
44379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44380       };
44381     }
44382   }
44383
44384   jresult = (void *)result;
44385   return jresult;
44386 }
44387
44388
44389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44390   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44391   SwigValueWrapper< Dali::Property > arg2 ;
44392   SwigValueWrapper< Dali::Property > arg3 ;
44393   Dali::Vector2 *arg4 = 0 ;
44394   Dali::Vector2 *arg5 = 0 ;
44395   Dali::Property *argp2 ;
44396   Dali::Property *argp3 ;
44397
44398   arg1 = (Dali::LinearConstrainer *)jarg1;
44399   argp2 = (Dali::Property *)jarg2;
44400   if (!argp2) {
44401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44402     return ;
44403   }
44404   arg2 = *argp2;
44405   argp3 = (Dali::Property *)jarg3;
44406   if (!argp3) {
44407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44408     return ;
44409   }
44410   arg3 = *argp3;
44411   arg4 = (Dali::Vector2 *)jarg4;
44412   if (!arg4) {
44413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44414     return ;
44415   }
44416   arg5 = (Dali::Vector2 *)jarg5;
44417   if (!arg5) {
44418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44419     return ;
44420   }
44421   {
44422     try {
44423       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44424     } catch (std::out_of_range& e) {
44425       {
44426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44427       };
44428     } catch (std::exception& e) {
44429       {
44430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44431       };
44432     } catch (Dali::DaliException e) {
44433       {
44434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44435       };
44436     } catch (...) {
44437       {
44438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44439       };
44440     }
44441   }
44442
44443 }
44444
44445
44446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44447   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44448   SwigValueWrapper< Dali::Property > arg2 ;
44449   SwigValueWrapper< Dali::Property > arg3 ;
44450   Dali::Vector2 *arg4 = 0 ;
44451   Dali::Property *argp2 ;
44452   Dali::Property *argp3 ;
44453
44454   arg1 = (Dali::LinearConstrainer *)jarg1;
44455   argp2 = (Dali::Property *)jarg2;
44456   if (!argp2) {
44457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44458     return ;
44459   }
44460   arg2 = *argp2;
44461   argp3 = (Dali::Property *)jarg3;
44462   if (!argp3) {
44463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44464     return ;
44465   }
44466   arg3 = *argp3;
44467   arg4 = (Dali::Vector2 *)jarg4;
44468   if (!arg4) {
44469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44470     return ;
44471   }
44472   {
44473     try {
44474       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44475     } catch (std::out_of_range& e) {
44476       {
44477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44478       };
44479     } catch (std::exception& e) {
44480       {
44481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44482       };
44483     } catch (Dali::DaliException e) {
44484       {
44485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44486       };
44487     } catch (...) {
44488       {
44489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44490       };
44491     }
44492   }
44493
44494 }
44495
44496
44497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44498   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44499   Dali::Handle *arg2 = 0 ;
44500
44501   arg1 = (Dali::LinearConstrainer *)jarg1;
44502   arg2 = (Dali::Handle *)jarg2;
44503   if (!arg2) {
44504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44505     return ;
44506   }
44507   {
44508     try {
44509       (arg1)->Remove(*arg2);
44510     } catch (std::out_of_range& e) {
44511       {
44512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44513       };
44514     } catch (std::exception& e) {
44515       {
44516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44517       };
44518     } catch (Dali::DaliException e) {
44519       {
44520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44521       };
44522     } catch (...) {
44523       {
44524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44525       };
44526     }
44527   }
44528
44529 }
44530
44531
44532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44533   int jresult ;
44534   int result;
44535
44536   result = (int)Dali::PathConstrainer::Property::FORWARD;
44537   jresult = (int)result;
44538   return jresult;
44539 }
44540
44541
44542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44543   int jresult ;
44544   int result;
44545
44546   result = (int)Dali::PathConstrainer::Property::POINTS;
44547   jresult = (int)result;
44548   return jresult;
44549 }
44550
44551
44552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44553   int jresult ;
44554   int result;
44555
44556   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44557   jresult = (int)result;
44558   return jresult;
44559 }
44560
44561
44562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44563   void * jresult ;
44564   Dali::PathConstrainer::Property *result = 0 ;
44565
44566   {
44567     try {
44568       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44569     } catch (std::out_of_range& e) {
44570       {
44571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44572       };
44573     } catch (std::exception& e) {
44574       {
44575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44576       };
44577     } catch (Dali::DaliException e) {
44578       {
44579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44580       };
44581     } catch (...) {
44582       {
44583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44584       };
44585     }
44586   }
44587
44588   jresult = (void *)result;
44589   return jresult;
44590 }
44591
44592
44593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44594   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44595
44596   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44597   {
44598     try {
44599       delete arg1;
44600     } catch (std::out_of_range& e) {
44601       {
44602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44603       };
44604     } catch (std::exception& e) {
44605       {
44606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44607       };
44608     } catch (Dali::DaliException e) {
44609       {
44610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44611       };
44612     } catch (...) {
44613       {
44614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44615       };
44616     }
44617   }
44618
44619 }
44620
44621
44622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44623   void * jresult ;
44624   Dali::PathConstrainer result;
44625
44626   {
44627     try {
44628       result = Dali::PathConstrainer::New();
44629     } catch (std::out_of_range& e) {
44630       {
44631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44632       };
44633     } catch (std::exception& e) {
44634       {
44635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44636       };
44637     } catch (Dali::DaliException e) {
44638       {
44639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44640       };
44641     } catch (...) {
44642       {
44643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44644       };
44645     }
44646   }
44647
44648   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44649   return jresult;
44650 }
44651
44652
44653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44654   void * jresult ;
44655   Dali::BaseHandle arg1 ;
44656   Dali::BaseHandle *argp1 ;
44657   Dali::PathConstrainer result;
44658
44659   argp1 = (Dali::BaseHandle *)jarg1;
44660   if (!argp1) {
44661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44662     return 0;
44663   }
44664   arg1 = *argp1;
44665   {
44666     try {
44667       result = Dali::PathConstrainer::DownCast(arg1);
44668     } catch (std::out_of_range& e) {
44669       {
44670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44671       };
44672     } catch (std::exception& e) {
44673       {
44674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44675       };
44676     } catch (Dali::DaliException e) {
44677       {
44678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44679       };
44680     } catch (...) {
44681       {
44682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44683       };
44684     }
44685   }
44686
44687   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44688   return jresult;
44689 }
44690
44691
44692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44693   void * jresult ;
44694   Dali::PathConstrainer *result = 0 ;
44695
44696   {
44697     try {
44698       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44699     } catch (std::out_of_range& e) {
44700       {
44701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44702       };
44703     } catch (std::exception& e) {
44704       {
44705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44706       };
44707     } catch (Dali::DaliException e) {
44708       {
44709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44710       };
44711     } catch (...) {
44712       {
44713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44714       };
44715     }
44716   }
44717
44718   jresult = (void *)result;
44719   return jresult;
44720 }
44721
44722
44723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44724   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44725
44726   arg1 = (Dali::PathConstrainer *)jarg1;
44727   {
44728     try {
44729       delete arg1;
44730     } catch (std::out_of_range& e) {
44731       {
44732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44733       };
44734     } catch (std::exception& e) {
44735       {
44736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44737       };
44738     } catch (Dali::DaliException e) {
44739       {
44740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44741       };
44742     } catch (...) {
44743       {
44744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44745       };
44746     }
44747   }
44748
44749 }
44750
44751
44752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44753   void * jresult ;
44754   Dali::PathConstrainer *arg1 = 0 ;
44755   Dali::PathConstrainer *result = 0 ;
44756
44757   arg1 = (Dali::PathConstrainer *)jarg1;
44758   if (!arg1) {
44759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44760     return 0;
44761   }
44762   {
44763     try {
44764       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44765     } catch (std::out_of_range& e) {
44766       {
44767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44768       };
44769     } catch (std::exception& e) {
44770       {
44771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44772       };
44773     } catch (Dali::DaliException e) {
44774       {
44775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44776       };
44777     } catch (...) {
44778       {
44779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44780       };
44781     }
44782   }
44783
44784   jresult = (void *)result;
44785   return jresult;
44786 }
44787
44788
44789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44790   void * jresult ;
44791   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44792   Dali::PathConstrainer *arg2 = 0 ;
44793   Dali::PathConstrainer *result = 0 ;
44794
44795   arg1 = (Dali::PathConstrainer *)jarg1;
44796   arg2 = (Dali::PathConstrainer *)jarg2;
44797   if (!arg2) {
44798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44799     return 0;
44800   }
44801   {
44802     try {
44803       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44804     } catch (std::out_of_range& e) {
44805       {
44806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44807       };
44808     } catch (std::exception& e) {
44809       {
44810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44811       };
44812     } catch (Dali::DaliException e) {
44813       {
44814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44815       };
44816     } catch (...) {
44817       {
44818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44819       };
44820     }
44821   }
44822
44823   jresult = (void *)result;
44824   return jresult;
44825 }
44826
44827
44828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44829   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44830   SwigValueWrapper< Dali::Property > arg2 ;
44831   SwigValueWrapper< Dali::Property > arg3 ;
44832   Dali::Vector2 *arg4 = 0 ;
44833   Dali::Vector2 *arg5 = 0 ;
44834   Dali::Property *argp2 ;
44835   Dali::Property *argp3 ;
44836
44837   arg1 = (Dali::PathConstrainer *)jarg1;
44838   argp2 = (Dali::Property *)jarg2;
44839   if (!argp2) {
44840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44841     return ;
44842   }
44843   arg2 = *argp2;
44844   argp3 = (Dali::Property *)jarg3;
44845   if (!argp3) {
44846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44847     return ;
44848   }
44849   arg3 = *argp3;
44850   arg4 = (Dali::Vector2 *)jarg4;
44851   if (!arg4) {
44852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44853     return ;
44854   }
44855   arg5 = (Dali::Vector2 *)jarg5;
44856   if (!arg5) {
44857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44858     return ;
44859   }
44860   {
44861     try {
44862       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44863     } catch (std::out_of_range& e) {
44864       {
44865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44866       };
44867     } catch (std::exception& e) {
44868       {
44869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44870       };
44871     } catch (Dali::DaliException e) {
44872       {
44873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44874       };
44875     } catch (...) {
44876       {
44877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44878       };
44879     }
44880   }
44881
44882 }
44883
44884
44885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44886   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44887   SwigValueWrapper< Dali::Property > arg2 ;
44888   SwigValueWrapper< Dali::Property > arg3 ;
44889   Dali::Vector2 *arg4 = 0 ;
44890   Dali::Property *argp2 ;
44891   Dali::Property *argp3 ;
44892
44893   arg1 = (Dali::PathConstrainer *)jarg1;
44894   argp2 = (Dali::Property *)jarg2;
44895   if (!argp2) {
44896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44897     return ;
44898   }
44899   arg2 = *argp2;
44900   argp3 = (Dali::Property *)jarg3;
44901   if (!argp3) {
44902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44903     return ;
44904   }
44905   arg3 = *argp3;
44906   arg4 = (Dali::Vector2 *)jarg4;
44907   if (!arg4) {
44908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44909     return ;
44910   }
44911   {
44912     try {
44913       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44914     } catch (std::out_of_range& e) {
44915       {
44916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44917       };
44918     } catch (std::exception& e) {
44919       {
44920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44921       };
44922     } catch (Dali::DaliException e) {
44923       {
44924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44925       };
44926     } catch (...) {
44927       {
44928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44929       };
44930     }
44931   }
44932
44933 }
44934
44935
44936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44937   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44938   Dali::Handle *arg2 = 0 ;
44939
44940   arg1 = (Dali::PathConstrainer *)jarg1;
44941   arg2 = (Dali::Handle *)jarg2;
44942   if (!arg2) {
44943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44944     return ;
44945   }
44946   {
44947     try {
44948       (arg1)->Remove(*arg2);
44949     } catch (std::out_of_range& e) {
44950       {
44951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44952       };
44953     } catch (std::exception& e) {
44954       {
44955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44956       };
44957     } catch (Dali::DaliException e) {
44958       {
44959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44960       };
44961     } catch (...) {
44962       {
44963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44964       };
44965     }
44966   }
44967
44968 }
44969
44970
44971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44972   int jresult ;
44973   Dali::FittingMode::Type result;
44974
44975   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44976   jresult = (int)result;
44977   return jresult;
44978 }
44979
44980
44981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44982   int jresult ;
44983   Dali::SamplingMode::Type result;
44984
44985   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44986   jresult = (int)result;
44987   return jresult;
44988 }
44989
44990
44991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
44992   void * jresult ;
44993   Dali::BufferImage *result = 0 ;
44994
44995   {
44996     try {
44997       result = (Dali::BufferImage *)new Dali::BufferImage();
44998     } catch (std::out_of_range& e) {
44999       {
45000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45001       };
45002     } catch (std::exception& e) {
45003       {
45004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45005       };
45006     } catch (Dali::DaliException e) {
45007       {
45008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45009       };
45010     } catch (...) {
45011       {
45012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45013       };
45014     }
45015   }
45016
45017   jresult = (void *)result;
45018   return jresult;
45019 }
45020
45021
45022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45023   void * jresult ;
45024   unsigned int arg1 ;
45025   unsigned int arg2 ;
45026   Dali::Pixel::Format arg3 ;
45027   Dali::BufferImage result;
45028
45029   arg1 = (unsigned int)jarg1;
45030   arg2 = (unsigned int)jarg2;
45031   arg3 = (Dali::Pixel::Format)jarg3;
45032   {
45033     try {
45034       result = Dali::BufferImage::New(arg1,arg2,arg3);
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 = new Dali::BufferImage((const Dali::BufferImage &)result);
45055   return jresult;
45056 }
45057
45058
45059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45060   void * jresult ;
45061   unsigned int arg1 ;
45062   unsigned int arg2 ;
45063   Dali::BufferImage result;
45064
45065   arg1 = (unsigned int)jarg1;
45066   arg2 = (unsigned int)jarg2;
45067   {
45068     try {
45069       result = Dali::BufferImage::New(arg1,arg2);
45070     } catch (std::out_of_range& e) {
45071       {
45072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45073       };
45074     } catch (std::exception& e) {
45075       {
45076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45077       };
45078     } catch (Dali::DaliException e) {
45079       {
45080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45081       };
45082     } catch (...) {
45083       {
45084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45085       };
45086     }
45087   }
45088
45089   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45090   return jresult;
45091 }
45092
45093
45094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45095   void * jresult ;
45096   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45097   unsigned int arg2 ;
45098   unsigned int arg3 ;
45099   Dali::Pixel::Format arg4 ;
45100   unsigned int arg5 ;
45101   Dali::BufferImage result;
45102
45103   arg1 = jarg1;
45104   arg2 = (unsigned int)jarg2;
45105   arg3 = (unsigned int)jarg3;
45106   arg4 = (Dali::Pixel::Format)jarg4;
45107   arg5 = (unsigned int)jarg5;
45108   {
45109     try {
45110       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45111     } catch (std::out_of_range& e) {
45112       {
45113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45114       };
45115     } catch (std::exception& e) {
45116       {
45117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45118       };
45119     } catch (Dali::DaliException e) {
45120       {
45121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45122       };
45123     } catch (...) {
45124       {
45125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45126       };
45127     }
45128   }
45129
45130   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45131
45132
45133   return jresult;
45134 }
45135
45136
45137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45138   void * jresult ;
45139   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45140   unsigned int arg2 ;
45141   unsigned int arg3 ;
45142   Dali::Pixel::Format arg4 ;
45143   Dali::BufferImage result;
45144
45145   arg1 = jarg1;
45146   arg2 = (unsigned int)jarg2;
45147   arg3 = (unsigned int)jarg3;
45148   arg4 = (Dali::Pixel::Format)jarg4;
45149   {
45150     try {
45151       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45152     } catch (std::out_of_range& e) {
45153       {
45154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45155       };
45156     } catch (std::exception& e) {
45157       {
45158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45159       };
45160     } catch (Dali::DaliException e) {
45161       {
45162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45163       };
45164     } catch (...) {
45165       {
45166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45167       };
45168     }
45169   }
45170
45171   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45172
45173
45174   return jresult;
45175 }
45176
45177
45178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45179   void * jresult ;
45180   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45181   unsigned int arg2 ;
45182   unsigned int arg3 ;
45183   Dali::BufferImage result;
45184
45185   arg1 = jarg1;
45186   arg2 = (unsigned int)jarg2;
45187   arg3 = (unsigned int)jarg3;
45188   {
45189     try {
45190       result = Dali::BufferImage::New(arg1,arg2,arg3);
45191     } catch (std::out_of_range& e) {
45192       {
45193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45194       };
45195     } catch (std::exception& e) {
45196       {
45197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45198       };
45199     } catch (Dali::DaliException e) {
45200       {
45201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45202       };
45203     } catch (...) {
45204       {
45205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45206       };
45207     }
45208   }
45209
45210   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45211
45212
45213   return jresult;
45214 }
45215
45216
45217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45218   void * jresult ;
45219   Dali::BaseHandle arg1 ;
45220   Dali::BaseHandle *argp1 ;
45221   Dali::BufferImage result;
45222
45223   argp1 = (Dali::BaseHandle *)jarg1;
45224   if (!argp1) {
45225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45226     return 0;
45227   }
45228   arg1 = *argp1;
45229   {
45230     try {
45231       result = Dali::BufferImage::DownCast(arg1);
45232     } catch (std::out_of_range& e) {
45233       {
45234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45235       };
45236     } catch (std::exception& e) {
45237       {
45238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45239       };
45240     } catch (Dali::DaliException e) {
45241       {
45242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45243       };
45244     } catch (...) {
45245       {
45246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45247       };
45248     }
45249   }
45250
45251   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45252   return jresult;
45253 }
45254
45255
45256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45257   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45258
45259   arg1 = (Dali::BufferImage *)jarg1;
45260   {
45261     try {
45262       delete arg1;
45263     } catch (std::out_of_range& e) {
45264       {
45265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45266       };
45267     } catch (std::exception& e) {
45268       {
45269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45270       };
45271     } catch (Dali::DaliException e) {
45272       {
45273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45274       };
45275     } catch (...) {
45276       {
45277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45278       };
45279     }
45280   }
45281
45282 }
45283
45284
45285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45286   void * jresult ;
45287   Dali::BufferImage *arg1 = 0 ;
45288   Dali::BufferImage *result = 0 ;
45289
45290   arg1 = (Dali::BufferImage *)jarg1;
45291   if (!arg1) {
45292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45293     return 0;
45294   }
45295   {
45296     try {
45297       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45298     } catch (std::out_of_range& e) {
45299       {
45300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45301       };
45302     } catch (std::exception& e) {
45303       {
45304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45305       };
45306     } catch (Dali::DaliException e) {
45307       {
45308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45309       };
45310     } catch (...) {
45311       {
45312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45313       };
45314     }
45315   }
45316
45317   jresult = (void *)result;
45318   return jresult;
45319 }
45320
45321
45322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45323   void * jresult ;
45324   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45325   Dali::BufferImage *arg2 = 0 ;
45326   Dali::BufferImage *result = 0 ;
45327
45328   arg1 = (Dali::BufferImage *)jarg1;
45329   arg2 = (Dali::BufferImage *)jarg2;
45330   if (!arg2) {
45331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45332     return 0;
45333   }
45334   {
45335     try {
45336       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45337     } catch (std::out_of_range& e) {
45338       {
45339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45340       };
45341     } catch (std::exception& e) {
45342       {
45343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45344       };
45345     } catch (Dali::DaliException e) {
45346       {
45347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45348       };
45349     } catch (...) {
45350       {
45351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45352       };
45353     }
45354   }
45355
45356   jresult = (void *)result;
45357   return jresult;
45358 }
45359
45360
45361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45362   void * jresult ;
45363   Dali::BufferImage result;
45364
45365   {
45366     try {
45367       result = Dali::BufferImage::WHITE();
45368     } catch (std::out_of_range& e) {
45369       {
45370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45371       };
45372     } catch (std::exception& e) {
45373       {
45374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45375       };
45376     } catch (Dali::DaliException e) {
45377       {
45378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45379       };
45380     } catch (...) {
45381       {
45382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45383       };
45384     }
45385   }
45386
45387   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45388   return jresult;
45389 }
45390
45391
45392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45393   void * jresult ;
45394   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45395   Dali::PixelBuffer *result = 0 ;
45396
45397   arg1 = (Dali::BufferImage *)jarg1;
45398   {
45399     try {
45400       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45401     } catch (std::out_of_range& e) {
45402       {
45403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45404       };
45405     } catch (std::exception& e) {
45406       {
45407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45408       };
45409     } catch (Dali::DaliException e) {
45410       {
45411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45412       };
45413     } catch (...) {
45414       {
45415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45416       };
45417     }
45418   }
45419
45420   jresult = (void *)result;
45421   return jresult;
45422 }
45423
45424
45425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45426   unsigned int jresult ;
45427   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45428   unsigned int result;
45429
45430   arg1 = (Dali::BufferImage *)jarg1;
45431   {
45432     try {
45433       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45434     } catch (std::out_of_range& e) {
45435       {
45436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45437       };
45438     } catch (std::exception& e) {
45439       {
45440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45441       };
45442     } catch (Dali::DaliException e) {
45443       {
45444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45445       };
45446     } catch (...) {
45447       {
45448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45449       };
45450     }
45451   }
45452
45453   jresult = result;
45454   return jresult;
45455 }
45456
45457
45458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45459   unsigned int jresult ;
45460   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45461   unsigned int result;
45462
45463   arg1 = (Dali::BufferImage *)jarg1;
45464   {
45465     try {
45466       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45467     } catch (std::out_of_range& e) {
45468       {
45469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45470       };
45471     } catch (std::exception& e) {
45472       {
45473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45474       };
45475     } catch (Dali::DaliException e) {
45476       {
45477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45478       };
45479     } catch (...) {
45480       {
45481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45482       };
45483     }
45484   }
45485
45486   jresult = result;
45487   return jresult;
45488 }
45489
45490
45491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45492   int jresult ;
45493   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45494   Dali::Pixel::Format result;
45495
45496   arg1 = (Dali::BufferImage *)jarg1;
45497   {
45498     try {
45499       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45500     } catch (std::out_of_range& e) {
45501       {
45502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45503       };
45504     } catch (std::exception& e) {
45505       {
45506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45507       };
45508     } catch (Dali::DaliException e) {
45509       {
45510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45511       };
45512     } catch (...) {
45513       {
45514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45515       };
45516     }
45517   }
45518
45519   jresult = (int)result;
45520   return jresult;
45521 }
45522
45523
45524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45525   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45526
45527   arg1 = (Dali::BufferImage *)jarg1;
45528   {
45529     try {
45530       (arg1)->Update();
45531     } catch (std::out_of_range& e) {
45532       {
45533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45534       };
45535     } catch (std::exception& e) {
45536       {
45537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45538       };
45539     } catch (Dali::DaliException e) {
45540       {
45541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45542       };
45543     } catch (...) {
45544       {
45545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45546       };
45547     }
45548   }
45549
45550 }
45551
45552
45553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45554   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45555   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45556   Dali::RectArea *argp2 ;
45557
45558   arg1 = (Dali::BufferImage *)jarg1;
45559   argp2 = (Dali::RectArea *)jarg2;
45560   if (!argp2) {
45561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45562     return ;
45563   }
45564   arg2 = *argp2;
45565   {
45566     try {
45567       (arg1)->Update(arg2);
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 unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45591   unsigned int jresult ;
45592   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45593   bool result;
45594
45595   arg1 = (Dali::BufferImage *)jarg1;
45596   {
45597     try {
45598       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45599     } catch (std::out_of_range& e) {
45600       {
45601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45602       };
45603     } catch (std::exception& e) {
45604       {
45605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45606       };
45607     } catch (Dali::DaliException e) {
45608       {
45609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45610       };
45611     } catch (...) {
45612       {
45613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45614       };
45615     }
45616   }
45617
45618   jresult = result;
45619   return jresult;
45620 }
45621
45622
45623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45624   void * jresult ;
45625   Dali::EncodedBufferImage *result = 0 ;
45626
45627   {
45628     try {
45629       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45630     } catch (std::out_of_range& e) {
45631       {
45632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45633       };
45634     } catch (std::exception& e) {
45635       {
45636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45637       };
45638     } catch (Dali::DaliException e) {
45639       {
45640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45641       };
45642     } catch (...) {
45643       {
45644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45645       };
45646     }
45647   }
45648
45649   jresult = (void *)result;
45650   return jresult;
45651 }
45652
45653
45654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45655   void * jresult ;
45656   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45657   std::size_t arg2 ;
45658   Dali::EncodedBufferImage result;
45659
45660   arg1 = (uint8_t *)jarg1;
45661   arg2 = (std::size_t)jarg2;
45662   {
45663     try {
45664       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45665     } catch (std::out_of_range& e) {
45666       {
45667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45668       };
45669     } catch (std::exception& e) {
45670       {
45671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45672       };
45673     } catch (Dali::DaliException e) {
45674       {
45675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45676       };
45677     } catch (...) {
45678       {
45679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45680       };
45681     }
45682   }
45683
45684   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45685   return jresult;
45686 }
45687
45688
45689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45690   void * jresult ;
45691   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45692   std::size_t arg2 ;
45693   Dali::ImageDimensions arg3 ;
45694   Dali::FittingMode::Type arg4 ;
45695   Dali::SamplingMode::Type arg5 ;
45696   bool arg6 ;
45697   Dali::ImageDimensions *argp3 ;
45698   Dali::EncodedBufferImage result;
45699
45700   arg1 = (uint8_t *)jarg1;
45701   arg2 = (std::size_t)jarg2;
45702   argp3 = (Dali::ImageDimensions *)jarg3;
45703   if (!argp3) {
45704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45705     return 0;
45706   }
45707   arg3 = *argp3;
45708   arg4 = (Dali::FittingMode::Type)jarg4;
45709   arg5 = (Dali::SamplingMode::Type)jarg5;
45710   arg6 = jarg6 ? true : false;
45711   {
45712     try {
45713       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45714     } catch (std::out_of_range& e) {
45715       {
45716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45717       };
45718     } catch (std::exception& e) {
45719       {
45720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45721       };
45722     } catch (Dali::DaliException e) {
45723       {
45724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45725       };
45726     } catch (...) {
45727       {
45728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45729       };
45730     }
45731   }
45732
45733   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45734   return jresult;
45735 }
45736
45737
45738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45739   void * jresult ;
45740   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45741   std::size_t arg2 ;
45742   Dali::ImageDimensions arg3 ;
45743   Dali::FittingMode::Type arg4 ;
45744   Dali::SamplingMode::Type arg5 ;
45745   Dali::ImageDimensions *argp3 ;
45746   Dali::EncodedBufferImage result;
45747
45748   arg1 = (uint8_t *)jarg1;
45749   arg2 = (std::size_t)jarg2;
45750   argp3 = (Dali::ImageDimensions *)jarg3;
45751   if (!argp3) {
45752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45753     return 0;
45754   }
45755   arg3 = *argp3;
45756   arg4 = (Dali::FittingMode::Type)jarg4;
45757   arg5 = (Dali::SamplingMode::Type)jarg5;
45758   {
45759     try {
45760       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45761     } catch (std::out_of_range& e) {
45762       {
45763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45764       };
45765     } catch (std::exception& e) {
45766       {
45767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45768       };
45769     } catch (Dali::DaliException e) {
45770       {
45771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45772       };
45773     } catch (...) {
45774       {
45775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45776       };
45777     }
45778   }
45779
45780   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45781   return jresult;
45782 }
45783
45784
45785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45786   void * jresult ;
45787   Dali::BaseHandle arg1 ;
45788   Dali::BaseHandle *argp1 ;
45789   Dali::EncodedBufferImage result;
45790
45791   argp1 = (Dali::BaseHandle *)jarg1;
45792   if (!argp1) {
45793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45794     return 0;
45795   }
45796   arg1 = *argp1;
45797   {
45798     try {
45799       result = Dali::EncodedBufferImage::DownCast(arg1);
45800     } catch (std::out_of_range& e) {
45801       {
45802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45803       };
45804     } catch (std::exception& e) {
45805       {
45806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45807       };
45808     } catch (Dali::DaliException e) {
45809       {
45810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45811       };
45812     } catch (...) {
45813       {
45814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45815       };
45816     }
45817   }
45818
45819   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45820   return jresult;
45821 }
45822
45823
45824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45825   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45826
45827   arg1 = (Dali::EncodedBufferImage *)jarg1;
45828   {
45829     try {
45830       delete arg1;
45831     } catch (std::out_of_range& e) {
45832       {
45833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45834       };
45835     } catch (std::exception& e) {
45836       {
45837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45838       };
45839     } catch (Dali::DaliException e) {
45840       {
45841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45842       };
45843     } catch (...) {
45844       {
45845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45846       };
45847     }
45848   }
45849
45850 }
45851
45852
45853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45854   void * jresult ;
45855   Dali::EncodedBufferImage *arg1 = 0 ;
45856   Dali::EncodedBufferImage *result = 0 ;
45857
45858   arg1 = (Dali::EncodedBufferImage *)jarg1;
45859   if (!arg1) {
45860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45861     return 0;
45862   }
45863   {
45864     try {
45865       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45866     } catch (std::out_of_range& e) {
45867       {
45868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45869       };
45870     } catch (std::exception& e) {
45871       {
45872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45873       };
45874     } catch (Dali::DaliException e) {
45875       {
45876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45877       };
45878     } catch (...) {
45879       {
45880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45881       };
45882     }
45883   }
45884
45885   jresult = (void *)result;
45886   return jresult;
45887 }
45888
45889
45890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45891   void * jresult ;
45892   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45893   Dali::EncodedBufferImage *arg2 = 0 ;
45894   Dali::EncodedBufferImage *result = 0 ;
45895
45896   arg1 = (Dali::EncodedBufferImage *)jarg1;
45897   arg2 = (Dali::EncodedBufferImage *)jarg2;
45898   if (!arg2) {
45899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45900     return 0;
45901   }
45902   {
45903     try {
45904       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45905     } catch (std::out_of_range& e) {
45906       {
45907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45908       };
45909     } catch (std::exception& e) {
45910       {
45911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45912       };
45913     } catch (Dali::DaliException e) {
45914       {
45915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45916       };
45917     } catch (...) {
45918       {
45919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45920       };
45921     }
45922   }
45923
45924   jresult = (void *)result;
45925   return jresult;
45926 }
45927
45928
45929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
45930   void * jresult ;
45931   Dali::NativeImage *result = 0 ;
45932
45933   {
45934     try {
45935       result = (Dali::NativeImage *)new Dali::NativeImage();
45936     } catch (std::out_of_range& e) {
45937       {
45938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45939       };
45940     } catch (std::exception& e) {
45941       {
45942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45943       };
45944     } catch (Dali::DaliException e) {
45945       {
45946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45947       };
45948     } catch (...) {
45949       {
45950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45951       };
45952     }
45953   }
45954
45955   jresult = (void *)result;
45956   return jresult;
45957 }
45958
45959
45960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
45961   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45962
45963   arg1 = (Dali::NativeImage *)jarg1;
45964   {
45965     try {
45966       delete arg1;
45967     } catch (std::out_of_range& e) {
45968       {
45969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45970       };
45971     } catch (std::exception& e) {
45972       {
45973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45974       };
45975     } catch (Dali::DaliException e) {
45976       {
45977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45978       };
45979     } catch (...) {
45980       {
45981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45982       };
45983     }
45984   }
45985
45986 }
45987
45988
45989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
45990   void * jresult ;
45991   Dali::NativeImage *arg1 = 0 ;
45992   Dali::NativeImage *result = 0 ;
45993
45994   arg1 = (Dali::NativeImage *)jarg1;
45995   if (!arg1) {
45996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
45997     return 0;
45998   }
45999   {
46000     try {
46001       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
46002     } catch (std::out_of_range& e) {
46003       {
46004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46005       };
46006     } catch (std::exception& e) {
46007       {
46008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46009       };
46010     } catch (Dali::DaliException e) {
46011       {
46012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46013       };
46014     } catch (...) {
46015       {
46016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46017       };
46018     }
46019   }
46020
46021   jresult = (void *)result;
46022   return jresult;
46023 }
46024
46025
46026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46027   void * jresult ;
46028   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46029   Dali::NativeImage *arg2 = 0 ;
46030   Dali::NativeImage *result = 0 ;
46031
46032   arg1 = (Dali::NativeImage *)jarg1;
46033   arg2 = (Dali::NativeImage *)jarg2;
46034   if (!arg2) {
46035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46036     return 0;
46037   }
46038   {
46039     try {
46040       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46041     } catch (std::out_of_range& e) {
46042       {
46043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46044       };
46045     } catch (std::exception& e) {
46046       {
46047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46048       };
46049     } catch (Dali::DaliException e) {
46050       {
46051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46052       };
46053     } catch (...) {
46054       {
46055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46056       };
46057     }
46058   }
46059
46060   jresult = (void *)result;
46061   return jresult;
46062 }
46063
46064
46065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46066   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46067
46068   arg1 = (Dali::NativeImage *)jarg1;
46069   {
46070     try {
46071       (arg1)->CreateGlTexture();
46072     } catch (std::out_of_range& e) {
46073       {
46074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46075       };
46076     } catch (std::exception& e) {
46077       {
46078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46079       };
46080     } catch (Dali::DaliException e) {
46081       {
46082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46083       };
46084     } catch (...) {
46085       {
46086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46087       };
46088     }
46089   }
46090
46091 }
46092
46093
46094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46095   void * jresult ;
46096   NativeImageInterface *arg1 = 0 ;
46097   Dali::NativeImage result;
46098
46099   arg1 = (NativeImageInterface *)jarg1;
46100   if (!arg1) {
46101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46102     return 0;
46103   }
46104   {
46105     try {
46106       result = Dali::NativeImage::New(*arg1);
46107     } catch (std::out_of_range& e) {
46108       {
46109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46110       };
46111     } catch (std::exception& e) {
46112       {
46113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46114       };
46115     } catch (Dali::DaliException e) {
46116       {
46117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46118       };
46119     } catch (...) {
46120       {
46121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46122       };
46123     }
46124   }
46125
46126   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46127   return jresult;
46128 }
46129
46130
46131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46132   void * jresult ;
46133   Dali::BaseHandle arg1 ;
46134   Dali::BaseHandle *argp1 ;
46135   Dali::NativeImage result;
46136
46137   argp1 = (Dali::BaseHandle *)jarg1;
46138   if (!argp1) {
46139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46140     return 0;
46141   }
46142   arg1 = *argp1;
46143   {
46144     try {
46145       result = Dali::NativeImage::DownCast(arg1);
46146     } catch (std::out_of_range& e) {
46147       {
46148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46149       };
46150     } catch (std::exception& e) {
46151       {
46152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46153       };
46154     } catch (Dali::DaliException e) {
46155       {
46156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46157       };
46158     } catch (...) {
46159       {
46160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46161       };
46162     }
46163   }
46164
46165   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46166   return jresult;
46167 }
46168
46169
46170 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46171   char * jresult ;
46172   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46173   char *result = 0 ;
46174
46175   arg1 = (Dali::NativeImage *)jarg1;
46176   {
46177     try {
46178       result = (char *)(arg1)->GetCustomFragmentPreFix();
46179     } catch (std::out_of_range& e) {
46180       {
46181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46182       };
46183     } catch (std::exception& e) {
46184       {
46185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46186       };
46187     } catch (Dali::DaliException e) {
46188       {
46189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46190       };
46191     } catch (...) {
46192       {
46193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46194       };
46195     }
46196   }
46197
46198   jresult = SWIG_csharp_string_callback((const char *)result);
46199   return jresult;
46200 }
46201
46202
46203 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46204   char * jresult ;
46205   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46206   char *result = 0 ;
46207
46208   arg1 = (Dali::NativeImage *)jarg1;
46209   {
46210     try {
46211       result = (char *)(arg1)->GetCustomSamplerTypename();
46212     } catch (std::out_of_range& e) {
46213       {
46214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46215       };
46216     } catch (std::exception& e) {
46217       {
46218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46219       };
46220     } catch (Dali::DaliException e) {
46221       {
46222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46223       };
46224     } catch (...) {
46225       {
46226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46227       };
46228     }
46229   }
46230
46231   jresult = SWIG_csharp_string_callback((const char *)result);
46232   return jresult;
46233 }
46234
46235
46236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46237   unsigned int jresult ;
46238   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46239   bool result;
46240
46241   arg1 = (Dali::NativeImageInterface *)jarg1;
46242   {
46243     try {
46244       result = (bool)(arg1)->GlExtensionCreate();
46245     } catch (std::out_of_range& e) {
46246       {
46247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46248       };
46249     } catch (std::exception& e) {
46250       {
46251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46252       };
46253     } catch (Dali::DaliException e) {
46254       {
46255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46256       };
46257     } catch (...) {
46258       {
46259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46260       };
46261     }
46262   }
46263
46264   jresult = result;
46265   return jresult;
46266 }
46267
46268
46269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46270   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46271
46272   arg1 = (Dali::NativeImageInterface *)jarg1;
46273   {
46274     try {
46275       (arg1)->GlExtensionDestroy();
46276     } catch (std::out_of_range& e) {
46277       {
46278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46279       };
46280     } catch (std::exception& e) {
46281       {
46282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46283       };
46284     } catch (Dali::DaliException e) {
46285       {
46286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46287       };
46288     } catch (...) {
46289       {
46290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46291       };
46292     }
46293   }
46294
46295 }
46296
46297
46298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46299   unsigned int jresult ;
46300   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46301   unsigned int result;
46302
46303   arg1 = (Dali::NativeImageInterface *)jarg1;
46304   {
46305     try {
46306       result = (unsigned int)(arg1)->TargetTexture();
46307     } catch (std::out_of_range& e) {
46308       {
46309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46310       };
46311     } catch (std::exception& e) {
46312       {
46313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46314       };
46315     } catch (Dali::DaliException e) {
46316       {
46317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46318       };
46319     } catch (...) {
46320       {
46321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46322       };
46323     }
46324   }
46325
46326   jresult = result;
46327   return jresult;
46328 }
46329
46330
46331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46332   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46333
46334   arg1 = (Dali::NativeImageInterface *)jarg1;
46335   {
46336     try {
46337       (arg1)->PrepareTexture();
46338     } catch (std::out_of_range& e) {
46339       {
46340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46341       };
46342     } catch (std::exception& e) {
46343       {
46344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46345       };
46346     } catch (Dali::DaliException e) {
46347       {
46348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46349       };
46350     } catch (...) {
46351       {
46352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46353       };
46354     }
46355   }
46356
46357 }
46358
46359
46360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46361   unsigned int jresult ;
46362   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46363   unsigned int result;
46364
46365   arg1 = (Dali::NativeImageInterface *)jarg1;
46366   {
46367     try {
46368       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46369     } catch (std::out_of_range& e) {
46370       {
46371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46372       };
46373     } catch (std::exception& e) {
46374       {
46375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46376       };
46377     } catch (Dali::DaliException e) {
46378       {
46379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46380       };
46381     } catch (...) {
46382       {
46383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46384       };
46385     }
46386   }
46387
46388   jresult = result;
46389   return jresult;
46390 }
46391
46392
46393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46394   unsigned int jresult ;
46395   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46396   unsigned int result;
46397
46398   arg1 = (Dali::NativeImageInterface *)jarg1;
46399   {
46400     try {
46401       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46402     } catch (std::out_of_range& e) {
46403       {
46404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46405       };
46406     } catch (std::exception& e) {
46407       {
46408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46409       };
46410     } catch (Dali::DaliException e) {
46411       {
46412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46413       };
46414     } catch (...) {
46415       {
46416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46417       };
46418     }
46419   }
46420
46421   jresult = result;
46422   return jresult;
46423 }
46424
46425
46426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46427   unsigned int jresult ;
46428   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46429   bool result;
46430
46431   arg1 = (Dali::NativeImageInterface *)jarg1;
46432   {
46433     try {
46434       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46435     } catch (std::out_of_range& e) {
46436       {
46437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46438       };
46439     } catch (std::exception& e) {
46440       {
46441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46442       };
46443     } catch (Dali::DaliException e) {
46444       {
46445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46446       };
46447     } catch (...) {
46448       {
46449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46450       };
46451     }
46452   }
46453
46454   jresult = result;
46455   return jresult;
46456 }
46457
46458
46459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46460   void * jresult ;
46461   std::string *arg1 = 0 ;
46462   Dali::ImageDimensions result;
46463
46464   if (!jarg1) {
46465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46466     return 0;
46467   }
46468   std::string arg1_str(jarg1);
46469   arg1 = &arg1_str;
46470   {
46471     try {
46472       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46473     } catch (std::out_of_range& e) {
46474       {
46475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46476       };
46477     } catch (std::exception& e) {
46478       {
46479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46480       };
46481     } catch (Dali::DaliException e) {
46482       {
46483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46484       };
46485     } catch (...) {
46486       {
46487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46488       };
46489     }
46490   }
46491
46492   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46493
46494   //argout typemap for const std::string&
46495
46496   return jresult;
46497 }
46498
46499
46500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46501   void * jresult ;
46502   Dali::ResourceImage *result = 0 ;
46503
46504   {
46505     try {
46506       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46507     } catch (std::out_of_range& e) {
46508       {
46509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46510       };
46511     } catch (std::exception& e) {
46512       {
46513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46514       };
46515     } catch (Dali::DaliException e) {
46516       {
46517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46518       };
46519     } catch (...) {
46520       {
46521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46522       };
46523     }
46524   }
46525
46526   jresult = (void *)result;
46527   return jresult;
46528 }
46529
46530
46531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46532   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46533
46534   arg1 = (Dali::ResourceImage *)jarg1;
46535   {
46536     try {
46537       delete arg1;
46538     } catch (std::out_of_range& e) {
46539       {
46540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46541       };
46542     } catch (std::exception& e) {
46543       {
46544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46545       };
46546     } catch (Dali::DaliException e) {
46547       {
46548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46549       };
46550     } catch (...) {
46551       {
46552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46553       };
46554     }
46555   }
46556
46557 }
46558
46559
46560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46561   void * jresult ;
46562   Dali::ResourceImage *arg1 = 0 ;
46563   Dali::ResourceImage *result = 0 ;
46564
46565   arg1 = (Dali::ResourceImage *)jarg1;
46566   if (!arg1) {
46567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46568     return 0;
46569   }
46570   {
46571     try {
46572       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46573     } catch (std::out_of_range& e) {
46574       {
46575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46576       };
46577     } catch (std::exception& e) {
46578       {
46579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46580       };
46581     } catch (Dali::DaliException e) {
46582       {
46583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46584       };
46585     } catch (...) {
46586       {
46587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46588       };
46589     }
46590   }
46591
46592   jresult = (void *)result;
46593   return jresult;
46594 }
46595
46596
46597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46598   void * jresult ;
46599   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46600   Dali::ResourceImage *arg2 = 0 ;
46601   Dali::ResourceImage *result = 0 ;
46602
46603   arg1 = (Dali::ResourceImage *)jarg1;
46604   arg2 = (Dali::ResourceImage *)jarg2;
46605   if (!arg2) {
46606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46607     return 0;
46608   }
46609   {
46610     try {
46611       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46612     } catch (std::out_of_range& e) {
46613       {
46614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46615       };
46616     } catch (std::exception& e) {
46617       {
46618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46619       };
46620     } catch (Dali::DaliException e) {
46621       {
46622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46623       };
46624     } catch (...) {
46625       {
46626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46627       };
46628     }
46629   }
46630
46631   jresult = (void *)result;
46632   return jresult;
46633 }
46634
46635
46636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46637   void * jresult ;
46638   std::string *arg1 = 0 ;
46639   bool arg2 ;
46640   Dali::ResourceImage result;
46641
46642   if (!jarg1) {
46643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46644     return 0;
46645   }
46646   std::string arg1_str(jarg1);
46647   arg1 = &arg1_str;
46648   arg2 = jarg2 ? true : false;
46649   {
46650     try {
46651       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46652     } catch (std::out_of_range& e) {
46653       {
46654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46655       };
46656     } catch (std::exception& e) {
46657       {
46658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46659       };
46660     } catch (Dali::DaliException e) {
46661       {
46662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46663       };
46664     } catch (...) {
46665       {
46666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46667       };
46668     }
46669   }
46670
46671   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46672
46673   //argout typemap for const std::string&
46674
46675   return jresult;
46676 }
46677
46678
46679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46680   void * jresult ;
46681   std::string *arg1 = 0 ;
46682   Dali::ResourceImage result;
46683
46684   if (!jarg1) {
46685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46686     return 0;
46687   }
46688   std::string arg1_str(jarg1);
46689   arg1 = &arg1_str;
46690   {
46691     try {
46692       result = Dali::ResourceImage::New((std::string const &)*arg1);
46693     } catch (std::out_of_range& e) {
46694       {
46695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46696       };
46697     } catch (std::exception& e) {
46698       {
46699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46700       };
46701     } catch (Dali::DaliException e) {
46702       {
46703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46704       };
46705     } catch (...) {
46706       {
46707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46708       };
46709     }
46710   }
46711
46712   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46713
46714   //argout typemap for const std::string&
46715
46716   return jresult;
46717 }
46718
46719
46720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46721   void * jresult ;
46722   std::string *arg1 = 0 ;
46723   Dali::ImageDimensions arg2 ;
46724   Dali::FittingMode::Type arg3 ;
46725   Dali::SamplingMode::Type arg4 ;
46726   bool arg5 ;
46727   Dali::ImageDimensions *argp2 ;
46728   Dali::ResourceImage result;
46729
46730   if (!jarg1) {
46731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46732     return 0;
46733   }
46734   std::string arg1_str(jarg1);
46735   arg1 = &arg1_str;
46736   argp2 = (Dali::ImageDimensions *)jarg2;
46737   if (!argp2) {
46738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46739     return 0;
46740   }
46741   arg2 = *argp2;
46742   arg3 = (Dali::FittingMode::Type)jarg3;
46743   arg4 = (Dali::SamplingMode::Type)jarg4;
46744   arg5 = jarg5 ? true : false;
46745   {
46746     try {
46747       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46748     } catch (std::out_of_range& e) {
46749       {
46750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46751       };
46752     } catch (std::exception& e) {
46753       {
46754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46755       };
46756     } catch (Dali::DaliException e) {
46757       {
46758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46759       };
46760     } catch (...) {
46761       {
46762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46763       };
46764     }
46765   }
46766
46767   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46768
46769   //argout typemap for const std::string&
46770
46771   return jresult;
46772 }
46773
46774
46775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46776   void * jresult ;
46777   std::string *arg1 = 0 ;
46778   Dali::ImageDimensions arg2 ;
46779   Dali::FittingMode::Type arg3 ;
46780   Dali::SamplingMode::Type arg4 ;
46781   Dali::ImageDimensions *argp2 ;
46782   Dali::ResourceImage result;
46783
46784   if (!jarg1) {
46785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46786     return 0;
46787   }
46788   std::string arg1_str(jarg1);
46789   arg1 = &arg1_str;
46790   argp2 = (Dali::ImageDimensions *)jarg2;
46791   if (!argp2) {
46792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46793     return 0;
46794   }
46795   arg2 = *argp2;
46796   arg3 = (Dali::FittingMode::Type)jarg3;
46797   arg4 = (Dali::SamplingMode::Type)jarg4;
46798   {
46799     try {
46800       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46801     } catch (std::out_of_range& e) {
46802       {
46803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46804       };
46805     } catch (std::exception& e) {
46806       {
46807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46808       };
46809     } catch (Dali::DaliException e) {
46810       {
46811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46812       };
46813     } catch (...) {
46814       {
46815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46816       };
46817     }
46818   }
46819
46820   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46821
46822   //argout typemap for const std::string&
46823
46824   return jresult;
46825 }
46826
46827
46828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46829   void * jresult ;
46830   std::string *arg1 = 0 ;
46831   Dali::ImageDimensions arg2 ;
46832   Dali::FittingMode::Type arg3 ;
46833   Dali::ImageDimensions *argp2 ;
46834   Dali::ResourceImage result;
46835
46836   if (!jarg1) {
46837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46838     return 0;
46839   }
46840   std::string arg1_str(jarg1);
46841   arg1 = &arg1_str;
46842   argp2 = (Dali::ImageDimensions *)jarg2;
46843   if (!argp2) {
46844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46845     return 0;
46846   }
46847   arg2 = *argp2;
46848   arg3 = (Dali::FittingMode::Type)jarg3;
46849   {
46850     try {
46851       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46852     } catch (std::out_of_range& e) {
46853       {
46854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46855       };
46856     } catch (std::exception& e) {
46857       {
46858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46859       };
46860     } catch (Dali::DaliException e) {
46861       {
46862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46863       };
46864     } catch (...) {
46865       {
46866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46867       };
46868     }
46869   }
46870
46871   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46872
46873   //argout typemap for const std::string&
46874
46875   return jresult;
46876 }
46877
46878
46879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46880   void * jresult ;
46881   std::string *arg1 = 0 ;
46882   Dali::ImageDimensions arg2 ;
46883   Dali::ImageDimensions *argp2 ;
46884   Dali::ResourceImage result;
46885
46886   if (!jarg1) {
46887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46888     return 0;
46889   }
46890   std::string arg1_str(jarg1);
46891   arg1 = &arg1_str;
46892   argp2 = (Dali::ImageDimensions *)jarg2;
46893   if (!argp2) {
46894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46895     return 0;
46896   }
46897   arg2 = *argp2;
46898   {
46899     try {
46900       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46901     } catch (std::out_of_range& e) {
46902       {
46903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46904       };
46905     } catch (std::exception& e) {
46906       {
46907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46908       };
46909     } catch (Dali::DaliException e) {
46910       {
46911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46912       };
46913     } catch (...) {
46914       {
46915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46916       };
46917     }
46918   }
46919
46920   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46921
46922   //argout typemap for const std::string&
46923
46924   return jresult;
46925 }
46926
46927
46928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46929   void * jresult ;
46930   Dali::BaseHandle arg1 ;
46931   Dali::BaseHandle *argp1 ;
46932   Dali::ResourceImage result;
46933
46934   argp1 = (Dali::BaseHandle *)jarg1;
46935   if (!argp1) {
46936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46937     return 0;
46938   }
46939   arg1 = *argp1;
46940   {
46941     try {
46942       result = Dali::ResourceImage::DownCast(arg1);
46943     } catch (std::out_of_range& e) {
46944       {
46945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46946       };
46947     } catch (std::exception& e) {
46948       {
46949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46950       };
46951     } catch (Dali::DaliException e) {
46952       {
46953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46954       };
46955     } catch (...) {
46956       {
46957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46958       };
46959     }
46960   }
46961
46962   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46963   return jresult;
46964 }
46965
46966
46967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
46968   int jresult ;
46969   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46970   Dali::LoadingState result;
46971
46972   arg1 = (Dali::ResourceImage *)jarg1;
46973   {
46974     try {
46975       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
46976     } catch (std::out_of_range& e) {
46977       {
46978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46979       };
46980     } catch (std::exception& e) {
46981       {
46982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46983       };
46984     } catch (Dali::DaliException e) {
46985       {
46986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46987       };
46988     } catch (...) {
46989       {
46990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46991       };
46992     }
46993   }
46994
46995   jresult = (int)result;
46996   return jresult;
46997 }
46998
46999
47000 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47001   char * jresult ;
47002   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47003   std::string result;
47004
47005   arg1 = (Dali::ResourceImage *)jarg1;
47006   {
47007     try {
47008       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47009     } catch (std::out_of_range& e) {
47010       {
47011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47012       };
47013     } catch (std::exception& e) {
47014       {
47015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47016       };
47017     } catch (Dali::DaliException e) {
47018       {
47019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47020       };
47021     } catch (...) {
47022       {
47023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47024       };
47025     }
47026   }
47027
47028   jresult = SWIG_csharp_string_callback((&result)->c_str());
47029   return jresult;
47030 }
47031
47032
47033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47034   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47035
47036   arg1 = (Dali::ResourceImage *)jarg1;
47037   {
47038     try {
47039       (arg1)->Reload();
47040     } catch (std::out_of_range& e) {
47041       {
47042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47043       };
47044     } catch (std::exception& e) {
47045       {
47046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47047       };
47048     } catch (Dali::DaliException e) {
47049       {
47050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47051       };
47052     } catch (...) {
47053       {
47054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47055       };
47056     }
47057   }
47058
47059 }
47060
47061
47062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47063   void * jresult ;
47064   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47065   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47066
47067   arg1 = (Dali::ResourceImage *)jarg1;
47068   {
47069     try {
47070       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47071     } catch (std::out_of_range& e) {
47072       {
47073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47074       };
47075     } catch (std::exception& e) {
47076       {
47077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47078       };
47079     } catch (Dali::DaliException e) {
47080       {
47081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47082       };
47083     } catch (...) {
47084       {
47085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47086       };
47087     }
47088   }
47089
47090   jresult = (void *)result;
47091   return jresult;
47092 }
47093
47094
47095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47096   void * jresult ;
47097   Dali::FrameBufferImage *result = 0 ;
47098
47099   {
47100     try {
47101       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47102     } catch (std::out_of_range& e) {
47103       {
47104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47105       };
47106     } catch (std::exception& e) {
47107       {
47108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47109       };
47110     } catch (Dali::DaliException e) {
47111       {
47112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47113       };
47114     } catch (...) {
47115       {
47116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47117       };
47118     }
47119   }
47120
47121   jresult = (void *)result;
47122   return jresult;
47123 }
47124
47125
47126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47127   void * jresult ;
47128   unsigned int arg1 ;
47129   unsigned int arg2 ;
47130   Dali::Pixel::Format arg3 ;
47131   Dali::RenderBuffer::Format arg4 ;
47132   Dali::FrameBufferImage result;
47133
47134   arg1 = (unsigned int)jarg1;
47135   arg2 = (unsigned int)jarg2;
47136   arg3 = (Dali::Pixel::Format)jarg3;
47137   arg4 = (Dali::RenderBuffer::Format)jarg4;
47138   {
47139     try {
47140       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47141     } catch (std::out_of_range& e) {
47142       {
47143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47144       };
47145     } catch (std::exception& e) {
47146       {
47147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47148       };
47149     } catch (Dali::DaliException e) {
47150       {
47151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47152       };
47153     } catch (...) {
47154       {
47155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47156       };
47157     }
47158   }
47159
47160   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47161   return jresult;
47162 }
47163
47164
47165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47166   void * jresult ;
47167   unsigned int arg1 ;
47168   unsigned int arg2 ;
47169   Dali::Pixel::Format arg3 ;
47170   Dali::FrameBufferImage result;
47171
47172   arg1 = (unsigned int)jarg1;
47173   arg2 = (unsigned int)jarg2;
47174   arg3 = (Dali::Pixel::Format)jarg3;
47175   {
47176     try {
47177       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
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_2(unsigned int jarg1, unsigned int jarg2) {
47203   void * jresult ;
47204   unsigned int arg1 ;
47205   unsigned int arg2 ;
47206   Dali::FrameBufferImage result;
47207
47208   arg1 = (unsigned int)jarg1;
47209   arg2 = (unsigned int)jarg2;
47210   {
47211     try {
47212       result = Dali::FrameBufferImage::New(arg1,arg2);
47213     } catch (std::out_of_range& e) {
47214       {
47215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47216       };
47217     } catch (std::exception& e) {
47218       {
47219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47220       };
47221     } catch (Dali::DaliException e) {
47222       {
47223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47224       };
47225     } catch (...) {
47226       {
47227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47228       };
47229     }
47230   }
47231
47232   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47233   return jresult;
47234 }
47235
47236
47237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47238   void * jresult ;
47239   unsigned int arg1 ;
47240   Dali::FrameBufferImage result;
47241
47242   arg1 = (unsigned int)jarg1;
47243   {
47244     try {
47245       result = Dali::FrameBufferImage::New(arg1);
47246     } catch (std::out_of_range& e) {
47247       {
47248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47249       };
47250     } catch (std::exception& e) {
47251       {
47252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47253       };
47254     } catch (Dali::DaliException e) {
47255       {
47256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47257       };
47258     } catch (...) {
47259       {
47260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47261       };
47262     }
47263   }
47264
47265   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47266   return jresult;
47267 }
47268
47269
47270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47271   void * jresult ;
47272   Dali::FrameBufferImage result;
47273
47274   {
47275     try {
47276       result = Dali::FrameBufferImage::New();
47277     } catch (std::out_of_range& e) {
47278       {
47279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47280       };
47281     } catch (std::exception& e) {
47282       {
47283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47284       };
47285     } catch (Dali::DaliException e) {
47286       {
47287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47288       };
47289     } catch (...) {
47290       {
47291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47292       };
47293     }
47294   }
47295
47296   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47297   return jresult;
47298 }
47299
47300
47301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47302   void * jresult ;
47303   Dali::NativeImageInterface *arg1 = 0 ;
47304   Dali::FrameBufferImage result;
47305
47306   arg1 = (Dali::NativeImageInterface *)jarg1;
47307   if (!arg1) {
47308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47309     return 0;
47310   }
47311   {
47312     try {
47313       result = Dali::FrameBufferImage::New(*arg1);
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_DownCast(void * jarg1) {
47339   void * jresult ;
47340   Dali::BaseHandle arg1 ;
47341   Dali::BaseHandle *argp1 ;
47342   Dali::FrameBufferImage result;
47343
47344   argp1 = (Dali::BaseHandle *)jarg1;
47345   if (!argp1) {
47346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47347     return 0;
47348   }
47349   arg1 = *argp1;
47350   {
47351     try {
47352       result = Dali::FrameBufferImage::DownCast(arg1);
47353     } catch (std::out_of_range& e) {
47354       {
47355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47356       };
47357     } catch (std::exception& e) {
47358       {
47359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47360       };
47361     } catch (Dali::DaliException e) {
47362       {
47363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47364       };
47365     } catch (...) {
47366       {
47367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47368       };
47369     }
47370   }
47371
47372   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47373   return jresult;
47374 }
47375
47376
47377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47378   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47379
47380   arg1 = (Dali::FrameBufferImage *)jarg1;
47381   {
47382     try {
47383       delete arg1;
47384     } catch (std::out_of_range& e) {
47385       {
47386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47387       };
47388     } catch (std::exception& e) {
47389       {
47390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47391       };
47392     } catch (Dali::DaliException e) {
47393       {
47394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47395       };
47396     } catch (...) {
47397       {
47398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47399       };
47400     }
47401   }
47402
47403 }
47404
47405
47406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47407   void * jresult ;
47408   Dali::FrameBufferImage *arg1 = 0 ;
47409   Dali::FrameBufferImage *result = 0 ;
47410
47411   arg1 = (Dali::FrameBufferImage *)jarg1;
47412   if (!arg1) {
47413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47414     return 0;
47415   }
47416   {
47417     try {
47418       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47419     } catch (std::out_of_range& e) {
47420       {
47421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47422       };
47423     } catch (std::exception& e) {
47424       {
47425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47426       };
47427     } catch (Dali::DaliException e) {
47428       {
47429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47430       };
47431     } catch (...) {
47432       {
47433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47434       };
47435     }
47436   }
47437
47438   jresult = (void *)result;
47439   return jresult;
47440 }
47441
47442
47443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47444   void * jresult ;
47445   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47446   Dali::FrameBufferImage *arg2 = 0 ;
47447   Dali::FrameBufferImage *result = 0 ;
47448
47449   arg1 = (Dali::FrameBufferImage *)jarg1;
47450   arg2 = (Dali::FrameBufferImage *)jarg2;
47451   if (!arg2) {
47452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47453     return 0;
47454   }
47455   {
47456     try {
47457       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47458     } catch (std::out_of_range& e) {
47459       {
47460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47461       };
47462     } catch (std::exception& e) {
47463       {
47464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47465       };
47466     } catch (Dali::DaliException e) {
47467       {
47468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47469       };
47470     } catch (...) {
47471       {
47472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47473       };
47474     }
47475   }
47476
47477   jresult = (void *)result;
47478   return jresult;
47479 }
47480
47481
47482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47483   void * jresult ;
47484   Dali::NinePatchImage *result = 0 ;
47485
47486   {
47487     try {
47488       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47489     } catch (std::out_of_range& e) {
47490       {
47491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47492       };
47493     } catch (std::exception& e) {
47494       {
47495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47496       };
47497     } catch (Dali::DaliException e) {
47498       {
47499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47500       };
47501     } catch (...) {
47502       {
47503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47504       };
47505     }
47506   }
47507
47508   jresult = (void *)result;
47509   return jresult;
47510 }
47511
47512
47513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47514   void * jresult ;
47515   std::string *arg1 = 0 ;
47516   Dali::NinePatchImage result;
47517
47518   if (!jarg1) {
47519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47520     return 0;
47521   }
47522   std::string arg1_str(jarg1);
47523   arg1 = &arg1_str;
47524   {
47525     try {
47526       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47527     } catch (std::out_of_range& e) {
47528       {
47529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47530       };
47531     } catch (std::exception& e) {
47532       {
47533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47534       };
47535     } catch (Dali::DaliException e) {
47536       {
47537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47538       };
47539     } catch (...) {
47540       {
47541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47542       };
47543     }
47544   }
47545
47546   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47547
47548   //argout typemap for const std::string&
47549
47550   return jresult;
47551 }
47552
47553
47554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47555   void * jresult ;
47556   Dali::BaseHandle arg1 ;
47557   Dali::BaseHandle *argp1 ;
47558   Dali::NinePatchImage result;
47559
47560   argp1 = (Dali::BaseHandle *)jarg1;
47561   if (!argp1) {
47562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47563     return 0;
47564   }
47565   arg1 = *argp1;
47566   {
47567     try {
47568       result = Dali::NinePatchImage::DownCast(arg1);
47569     } catch (std::out_of_range& e) {
47570       {
47571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47572       };
47573     } catch (std::exception& e) {
47574       {
47575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47576       };
47577     } catch (Dali::DaliException e) {
47578       {
47579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47580       };
47581     } catch (...) {
47582       {
47583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47584       };
47585     }
47586   }
47587
47588   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47589   return jresult;
47590 }
47591
47592
47593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47594   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47595
47596   arg1 = (Dali::NinePatchImage *)jarg1;
47597   {
47598     try {
47599       delete arg1;
47600     } catch (std::out_of_range& e) {
47601       {
47602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47603       };
47604     } catch (std::exception& e) {
47605       {
47606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47607       };
47608     } catch (Dali::DaliException e) {
47609       {
47610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47611       };
47612     } catch (...) {
47613       {
47614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47615       };
47616     }
47617   }
47618
47619 }
47620
47621
47622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47623   void * jresult ;
47624   Dali::NinePatchImage *arg1 = 0 ;
47625   Dali::NinePatchImage *result = 0 ;
47626
47627   arg1 = (Dali::NinePatchImage *)jarg1;
47628   if (!arg1) {
47629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47630     return 0;
47631   }
47632   {
47633     try {
47634       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47635     } catch (std::out_of_range& e) {
47636       {
47637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47638       };
47639     } catch (std::exception& e) {
47640       {
47641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47642       };
47643     } catch (Dali::DaliException e) {
47644       {
47645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47646       };
47647     } catch (...) {
47648       {
47649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47650       };
47651     }
47652   }
47653
47654   jresult = (void *)result;
47655   return jresult;
47656 }
47657
47658
47659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47660   void * jresult ;
47661   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47662   Dali::NinePatchImage *arg2 = 0 ;
47663   Dali::NinePatchImage *result = 0 ;
47664
47665   arg1 = (Dali::NinePatchImage *)jarg1;
47666   arg2 = (Dali::NinePatchImage *)jarg2;
47667   if (!arg2) {
47668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47669     return 0;
47670   }
47671   {
47672     try {
47673       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47674     } catch (std::out_of_range& e) {
47675       {
47676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47677       };
47678     } catch (std::exception& e) {
47679       {
47680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47681       };
47682     } catch (Dali::DaliException e) {
47683       {
47684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47685       };
47686     } catch (...) {
47687       {
47688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47689       };
47690     }
47691   }
47692
47693   jresult = (void *)result;
47694   return jresult;
47695 }
47696
47697
47698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47699   void * jresult ;
47700   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47701   Dali::Vector4 result;
47702
47703   arg1 = (Dali::NinePatchImage *)jarg1;
47704   {
47705     try {
47706       result = (arg1)->GetStretchBorders();
47707     } catch (std::out_of_range& e) {
47708       {
47709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47710       };
47711     } catch (std::exception& e) {
47712       {
47713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47714       };
47715     } catch (Dali::DaliException e) {
47716       {
47717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47718       };
47719     } catch (...) {
47720       {
47721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47722       };
47723     }
47724   }
47725
47726   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47727   return jresult;
47728 }
47729
47730
47731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47732   void * jresult ;
47733   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47734   Dali::NinePatchImage::StretchRanges *result = 0 ;
47735
47736   arg1 = (Dali::NinePatchImage *)jarg1;
47737   {
47738     try {
47739       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47740     } catch (std::out_of_range& e) {
47741       {
47742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47743       };
47744     } catch (std::exception& e) {
47745       {
47746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47747       };
47748     } catch (Dali::DaliException e) {
47749       {
47750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47751       };
47752     } catch (...) {
47753       {
47754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47755       };
47756     }
47757   }
47758
47759   jresult = (void *)result;
47760   return jresult;
47761 }
47762
47763
47764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47765   void * jresult ;
47766   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47767   Dali::NinePatchImage::StretchRanges *result = 0 ;
47768
47769   arg1 = (Dali::NinePatchImage *)jarg1;
47770   {
47771     try {
47772       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47773     } catch (std::out_of_range& e) {
47774       {
47775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47776       };
47777     } catch (std::exception& e) {
47778       {
47779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47780       };
47781     } catch (Dali::DaliException e) {
47782       {
47783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47784       };
47785     } catch (...) {
47786       {
47787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47788       };
47789     }
47790   }
47791
47792   jresult = (void *)result;
47793   return jresult;
47794 }
47795
47796
47797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47798   void * jresult ;
47799   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47800   Dali::Rect< int > result;
47801
47802   arg1 = (Dali::NinePatchImage *)jarg1;
47803   {
47804     try {
47805       result = (arg1)->GetChildRectangle();
47806     } catch (std::out_of_range& e) {
47807       {
47808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47809       };
47810     } catch (std::exception& e) {
47811       {
47812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47813       };
47814     } catch (Dali::DaliException e) {
47815       {
47816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47817       };
47818     } catch (...) {
47819       {
47820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47821       };
47822     }
47823   }
47824
47825   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47826   return jresult;
47827 }
47828
47829
47830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47831   void * jresult ;
47832   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47833   Dali::BufferImage result;
47834
47835   arg1 = (Dali::NinePatchImage *)jarg1;
47836   {
47837     try {
47838       result = (arg1)->CreateCroppedBufferImage();
47839     } catch (std::out_of_range& e) {
47840       {
47841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47842       };
47843     } catch (std::exception& e) {
47844       {
47845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47846       };
47847     } catch (Dali::DaliException e) {
47848       {
47849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47850       };
47851     } catch (...) {
47852       {
47853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47854       };
47855     }
47856   }
47857
47858   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47859   return jresult;
47860 }
47861
47862
47863 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47864   unsigned int jresult ;
47865   std::string *arg1 = 0 ;
47866   bool result;
47867
47868   if (!jarg1) {
47869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47870     return 0;
47871   }
47872   std::string arg1_str(jarg1);
47873   arg1 = &arg1_str;
47874   {
47875     try {
47876       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47877     } catch (std::out_of_range& e) {
47878       {
47879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47880       };
47881     } catch (std::exception& e) {
47882       {
47883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47884       };
47885     } catch (Dali::DaliException e) {
47886       {
47887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47888       };
47889     } catch (...) {
47890       {
47891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47892       };
47893     }
47894   }
47895
47896   jresult = result;
47897
47898   //argout typemap for const std::string&
47899
47900   return jresult;
47901 }
47902
47903
47904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47905   int jresult ;
47906   int result;
47907
47908   result = (int)Dali::CameraActor::Property::TYPE;
47909   jresult = (int)result;
47910   return jresult;
47911 }
47912
47913
47914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
47915   int jresult ;
47916   int result;
47917
47918   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
47919   jresult = (int)result;
47920   return jresult;
47921 }
47922
47923
47924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
47925   int jresult ;
47926   int result;
47927
47928   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
47929   jresult = (int)result;
47930   return jresult;
47931 }
47932
47933
47934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
47935   int jresult ;
47936   int result;
47937
47938   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
47939   jresult = (int)result;
47940   return jresult;
47941 }
47942
47943
47944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
47945   int jresult ;
47946   int result;
47947
47948   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
47949   jresult = (int)result;
47950   return jresult;
47951 }
47952
47953
47954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
47955   int jresult ;
47956   int result;
47957
47958   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
47959   jresult = (int)result;
47960   return jresult;
47961 }
47962
47963
47964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
47965   int jresult ;
47966   int result;
47967
47968   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
47969   jresult = (int)result;
47970   return jresult;
47971 }
47972
47973
47974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
47975   int jresult ;
47976   int result;
47977
47978   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
47979   jresult = (int)result;
47980   return jresult;
47981 }
47982
47983
47984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
47985   int jresult ;
47986   int result;
47987
47988   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
47989   jresult = (int)result;
47990   return jresult;
47991 }
47992
47993
47994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
47995   int jresult ;
47996   int result;
47997
47998   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
47999   jresult = (int)result;
48000   return jresult;
48001 }
48002
48003
48004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48005   int jresult ;
48006   int result;
48007
48008   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48009   jresult = (int)result;
48010   return jresult;
48011 }
48012
48013
48014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48015   int jresult ;
48016   int result;
48017
48018   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48019   jresult = (int)result;
48020   return jresult;
48021 }
48022
48023
48024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48025   int jresult ;
48026   int result;
48027
48028   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48029   jresult = (int)result;
48030   return jresult;
48031 }
48032
48033
48034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48035   int jresult ;
48036   int result;
48037
48038   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48039   jresult = (int)result;
48040   return jresult;
48041 }
48042
48043
48044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48045   void * jresult ;
48046   Dali::CameraActor::Property *result = 0 ;
48047
48048   {
48049     try {
48050       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48051     } catch (std::out_of_range& e) {
48052       {
48053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48054       };
48055     } catch (std::exception& e) {
48056       {
48057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48058       };
48059     } catch (Dali::DaliException e) {
48060       {
48061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48062       };
48063     } catch (...) {
48064       {
48065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48066       };
48067     }
48068   }
48069
48070   jresult = (void *)result;
48071   return jresult;
48072 }
48073
48074
48075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48076   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48077
48078   arg1 = (Dali::CameraActor::Property *)jarg1;
48079   {
48080     try {
48081       delete arg1;
48082     } catch (std::out_of_range& e) {
48083       {
48084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48085       };
48086     } catch (std::exception& e) {
48087       {
48088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48089       };
48090     } catch (Dali::DaliException e) {
48091       {
48092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48093       };
48094     } catch (...) {
48095       {
48096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48097       };
48098     }
48099   }
48100
48101 }
48102
48103
48104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48105   void * jresult ;
48106   Dali::CameraActor *result = 0 ;
48107
48108   {
48109     try {
48110       result = (Dali::CameraActor *)new Dali::CameraActor();
48111     } catch (std::out_of_range& e) {
48112       {
48113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48114       };
48115     } catch (std::exception& e) {
48116       {
48117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48118       };
48119     } catch (Dali::DaliException e) {
48120       {
48121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48122       };
48123     } catch (...) {
48124       {
48125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48126       };
48127     }
48128   }
48129
48130   jresult = (void *)result;
48131   return jresult;
48132 }
48133
48134
48135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48136   void * jresult ;
48137   Dali::CameraActor result;
48138
48139   {
48140     try {
48141       result = Dali::CameraActor::New();
48142     } catch (std::out_of_range& e) {
48143       {
48144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48145       };
48146     } catch (std::exception& e) {
48147       {
48148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48149       };
48150     } catch (Dali::DaliException e) {
48151       {
48152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48153       };
48154     } catch (...) {
48155       {
48156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48157       };
48158     }
48159   }
48160
48161   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48162   return jresult;
48163 }
48164
48165
48166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48167   void * jresult ;
48168   Dali::Size *arg1 = 0 ;
48169   Dali::CameraActor result;
48170
48171   arg1 = (Dali::Size *)jarg1;
48172   if (!arg1) {
48173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48174     return 0;
48175   }
48176   {
48177     try {
48178       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
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_DownCast(void * jarg1) {
48204   void * jresult ;
48205   Dali::BaseHandle arg1 ;
48206   Dali::BaseHandle *argp1 ;
48207   Dali::CameraActor result;
48208
48209   argp1 = (Dali::BaseHandle *)jarg1;
48210   if (!argp1) {
48211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48212     return 0;
48213   }
48214   arg1 = *argp1;
48215   {
48216     try {
48217       result = Dali::CameraActor::DownCast(arg1);
48218     } catch (std::out_of_range& e) {
48219       {
48220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48221       };
48222     } catch (std::exception& e) {
48223       {
48224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48225       };
48226     } catch (Dali::DaliException e) {
48227       {
48228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48229       };
48230     } catch (...) {
48231       {
48232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48233       };
48234     }
48235   }
48236
48237   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48238   return jresult;
48239 }
48240
48241
48242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48243   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48244
48245   arg1 = (Dali::CameraActor *)jarg1;
48246   {
48247     try {
48248       delete arg1;
48249     } catch (std::out_of_range& e) {
48250       {
48251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48252       };
48253     } catch (std::exception& e) {
48254       {
48255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48256       };
48257     } catch (Dali::DaliException e) {
48258       {
48259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48260       };
48261     } catch (...) {
48262       {
48263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48264       };
48265     }
48266   }
48267
48268 }
48269
48270
48271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48272   void * jresult ;
48273   Dali::CameraActor *arg1 = 0 ;
48274   Dali::CameraActor *result = 0 ;
48275
48276   arg1 = (Dali::CameraActor *)jarg1;
48277   if (!arg1) {
48278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48279     return 0;
48280   }
48281   {
48282     try {
48283       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48284     } catch (std::out_of_range& e) {
48285       {
48286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48287       };
48288     } catch (std::exception& e) {
48289       {
48290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48291       };
48292     } catch (Dali::DaliException e) {
48293       {
48294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48295       };
48296     } catch (...) {
48297       {
48298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48299       };
48300     }
48301   }
48302
48303   jresult = (void *)result;
48304   return jresult;
48305 }
48306
48307
48308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48309   void * jresult ;
48310   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48311   Dali::CameraActor *arg2 = 0 ;
48312   Dali::CameraActor *result = 0 ;
48313
48314   arg1 = (Dali::CameraActor *)jarg1;
48315   arg2 = (Dali::CameraActor *)jarg2;
48316   if (!arg2) {
48317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48318     return 0;
48319   }
48320   {
48321     try {
48322       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48323     } catch (std::out_of_range& e) {
48324       {
48325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48326       };
48327     } catch (std::exception& e) {
48328       {
48329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48330       };
48331     } catch (Dali::DaliException e) {
48332       {
48333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48334       };
48335     } catch (...) {
48336       {
48337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48338       };
48339     }
48340   }
48341
48342   jresult = (void *)result;
48343   return jresult;
48344 }
48345
48346
48347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48348   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48349   Dali::Camera::Type arg2 ;
48350
48351   arg1 = (Dali::CameraActor *)jarg1;
48352   arg2 = (Dali::Camera::Type)jarg2;
48353   {
48354     try {
48355       (arg1)->SetType(arg2);
48356     } catch (std::out_of_range& e) {
48357       {
48358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48359       };
48360     } catch (std::exception& e) {
48361       {
48362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48363       };
48364     } catch (Dali::DaliException e) {
48365       {
48366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48367       };
48368     } catch (...) {
48369       {
48370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48371       };
48372     }
48373   }
48374
48375 }
48376
48377
48378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48379   int jresult ;
48380   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48381   Dali::Camera::Type result;
48382
48383   arg1 = (Dali::CameraActor *)jarg1;
48384   {
48385     try {
48386       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48387     } catch (std::out_of_range& e) {
48388       {
48389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48390       };
48391     } catch (std::exception& e) {
48392       {
48393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48394       };
48395     } catch (Dali::DaliException e) {
48396       {
48397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48398       };
48399     } catch (...) {
48400       {
48401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48402       };
48403     }
48404   }
48405
48406   jresult = (int)result;
48407   return jresult;
48408 }
48409
48410
48411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48412   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48413   Dali::Camera::ProjectionMode arg2 ;
48414
48415   arg1 = (Dali::CameraActor *)jarg1;
48416   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48417   {
48418     try {
48419       (arg1)->SetProjectionMode(arg2);
48420     } catch (std::out_of_range& e) {
48421       {
48422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48423       };
48424     } catch (std::exception& e) {
48425       {
48426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48427       };
48428     } catch (Dali::DaliException e) {
48429       {
48430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48431       };
48432     } catch (...) {
48433       {
48434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48435       };
48436     }
48437   }
48438
48439 }
48440
48441
48442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48443   int jresult ;
48444   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48445   Dali::Camera::ProjectionMode result;
48446
48447   arg1 = (Dali::CameraActor *)jarg1;
48448   {
48449     try {
48450       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48451     } catch (std::out_of_range& e) {
48452       {
48453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48454       };
48455     } catch (std::exception& e) {
48456       {
48457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48458       };
48459     } catch (Dali::DaliException e) {
48460       {
48461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48462       };
48463     } catch (...) {
48464       {
48465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48466       };
48467     }
48468   }
48469
48470   jresult = (int)result;
48471   return jresult;
48472 }
48473
48474
48475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48476   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48477   float arg2 ;
48478
48479   arg1 = (Dali::CameraActor *)jarg1;
48480   arg2 = (float)jarg2;
48481   {
48482     try {
48483       (arg1)->SetFieldOfView(arg2);
48484     } catch (std::out_of_range& e) {
48485       {
48486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48487       };
48488     } catch (std::exception& e) {
48489       {
48490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48491       };
48492     } catch (Dali::DaliException e) {
48493       {
48494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48495       };
48496     } catch (...) {
48497       {
48498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48499       };
48500     }
48501   }
48502
48503 }
48504
48505
48506 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48507   float jresult ;
48508   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48509   float result;
48510
48511   arg1 = (Dali::CameraActor *)jarg1;
48512   {
48513     try {
48514       result = (float)(arg1)->GetFieldOfView();
48515     } catch (std::out_of_range& e) {
48516       {
48517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48518       };
48519     } catch (std::exception& e) {
48520       {
48521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48522       };
48523     } catch (Dali::DaliException e) {
48524       {
48525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48526       };
48527     } catch (...) {
48528       {
48529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48530       };
48531     }
48532   }
48533
48534   jresult = result;
48535   return jresult;
48536 }
48537
48538
48539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48540   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48541   float arg2 ;
48542
48543   arg1 = (Dali::CameraActor *)jarg1;
48544   arg2 = (float)jarg2;
48545   {
48546     try {
48547       (arg1)->SetAspectRatio(arg2);
48548     } catch (std::out_of_range& e) {
48549       {
48550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48551       };
48552     } catch (std::exception& e) {
48553       {
48554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48555       };
48556     } catch (Dali::DaliException e) {
48557       {
48558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48559       };
48560     } catch (...) {
48561       {
48562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48563       };
48564     }
48565   }
48566
48567 }
48568
48569
48570 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48571   float jresult ;
48572   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48573   float result;
48574
48575   arg1 = (Dali::CameraActor *)jarg1;
48576   {
48577     try {
48578       result = (float)(arg1)->GetAspectRatio();
48579     } catch (std::out_of_range& e) {
48580       {
48581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48582       };
48583     } catch (std::exception& e) {
48584       {
48585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48586       };
48587     } catch (Dali::DaliException e) {
48588       {
48589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48590       };
48591     } catch (...) {
48592       {
48593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48594       };
48595     }
48596   }
48597
48598   jresult = result;
48599   return jresult;
48600 }
48601
48602
48603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48604   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48605   float arg2 ;
48606
48607   arg1 = (Dali::CameraActor *)jarg1;
48608   arg2 = (float)jarg2;
48609   {
48610     try {
48611       (arg1)->SetNearClippingPlane(arg2);
48612     } catch (std::out_of_range& e) {
48613       {
48614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48615       };
48616     } catch (std::exception& e) {
48617       {
48618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48619       };
48620     } catch (Dali::DaliException e) {
48621       {
48622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48623       };
48624     } catch (...) {
48625       {
48626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48627       };
48628     }
48629   }
48630
48631 }
48632
48633
48634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48635   float jresult ;
48636   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48637   float result;
48638
48639   arg1 = (Dali::CameraActor *)jarg1;
48640   {
48641     try {
48642       result = (float)(arg1)->GetNearClippingPlane();
48643     } catch (std::out_of_range& e) {
48644       {
48645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48646       };
48647     } catch (std::exception& e) {
48648       {
48649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48650       };
48651     } catch (Dali::DaliException e) {
48652       {
48653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48654       };
48655     } catch (...) {
48656       {
48657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48658       };
48659     }
48660   }
48661
48662   jresult = result;
48663   return jresult;
48664 }
48665
48666
48667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48668   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48669   float arg2 ;
48670
48671   arg1 = (Dali::CameraActor *)jarg1;
48672   arg2 = (float)jarg2;
48673   {
48674     try {
48675       (arg1)->SetFarClippingPlane(arg2);
48676     } catch (std::out_of_range& e) {
48677       {
48678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48679       };
48680     } catch (std::exception& e) {
48681       {
48682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48683       };
48684     } catch (Dali::DaliException e) {
48685       {
48686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48687       };
48688     } catch (...) {
48689       {
48690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48691       };
48692     }
48693   }
48694
48695 }
48696
48697
48698 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48699   float jresult ;
48700   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48701   float result;
48702
48703   arg1 = (Dali::CameraActor *)jarg1;
48704   {
48705     try {
48706       result = (float)(arg1)->GetFarClippingPlane();
48707     } catch (std::out_of_range& e) {
48708       {
48709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48710       };
48711     } catch (std::exception& e) {
48712       {
48713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48714       };
48715     } catch (Dali::DaliException e) {
48716       {
48717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48718       };
48719     } catch (...) {
48720       {
48721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48722       };
48723     }
48724   }
48725
48726   jresult = result;
48727   return jresult;
48728 }
48729
48730
48731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48732   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48733   Dali::Vector3 *arg2 = 0 ;
48734
48735   arg1 = (Dali::CameraActor *)jarg1;
48736   arg2 = (Dali::Vector3 *)jarg2;
48737   if (!arg2) {
48738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48739     return ;
48740   }
48741   {
48742     try {
48743       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48744     } catch (std::out_of_range& e) {
48745       {
48746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48747       };
48748     } catch (std::exception& e) {
48749       {
48750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48751       };
48752     } catch (Dali::DaliException e) {
48753       {
48754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48755       };
48756     } catch (...) {
48757       {
48758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48759       };
48760     }
48761   }
48762
48763 }
48764
48765
48766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48767   void * jresult ;
48768   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48769   Dali::Vector3 result;
48770
48771   arg1 = (Dali::CameraActor *)jarg1;
48772   {
48773     try {
48774       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48775     } catch (std::out_of_range& e) {
48776       {
48777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48778       };
48779     } catch (std::exception& e) {
48780       {
48781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48782       };
48783     } catch (Dali::DaliException e) {
48784       {
48785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48786       };
48787     } catch (...) {
48788       {
48789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48790       };
48791     }
48792   }
48793
48794   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48795   return jresult;
48796 }
48797
48798
48799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48800   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48801   bool arg2 ;
48802
48803   arg1 = (Dali::CameraActor *)jarg1;
48804   arg2 = jarg2 ? true : false;
48805   {
48806     try {
48807       (arg1)->SetInvertYAxis(arg2);
48808     } catch (std::out_of_range& e) {
48809       {
48810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48811       };
48812     } catch (std::exception& e) {
48813       {
48814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48815       };
48816     } catch (Dali::DaliException e) {
48817       {
48818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48819       };
48820     } catch (...) {
48821       {
48822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48823       };
48824     }
48825   }
48826
48827 }
48828
48829
48830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48831   unsigned int jresult ;
48832   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48833   bool result;
48834
48835   arg1 = (Dali::CameraActor *)jarg1;
48836   {
48837     try {
48838       result = (bool)(arg1)->GetInvertYAxis();
48839     } catch (std::out_of_range& e) {
48840       {
48841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48842       };
48843     } catch (std::exception& e) {
48844       {
48845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48846       };
48847     } catch (Dali::DaliException e) {
48848       {
48849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48850       };
48851     } catch (...) {
48852       {
48853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48854       };
48855     }
48856   }
48857
48858   jresult = result;
48859   return jresult;
48860 }
48861
48862
48863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48864   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48865   Dali::Size *arg2 = 0 ;
48866
48867   arg1 = (Dali::CameraActor *)jarg1;
48868   arg2 = (Dali::Size *)jarg2;
48869   if (!arg2) {
48870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48871     return ;
48872   }
48873   {
48874     try {
48875       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48876     } catch (std::out_of_range& e) {
48877       {
48878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48879       };
48880     } catch (std::exception& e) {
48881       {
48882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48883       };
48884     } catch (Dali::DaliException e) {
48885       {
48886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48887       };
48888     } catch (...) {
48889       {
48890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48891       };
48892     }
48893   }
48894
48895 }
48896
48897
48898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48899   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48900   Dali::Size *arg2 = 0 ;
48901
48902   arg1 = (Dali::CameraActor *)jarg1;
48903   arg2 = (Dali::Size *)jarg2;
48904   if (!arg2) {
48905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48906     return ;
48907   }
48908   {
48909     try {
48910       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48911     } catch (std::out_of_range& e) {
48912       {
48913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48914       };
48915     } catch (std::exception& e) {
48916       {
48917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48918       };
48919     } catch (Dali::DaliException e) {
48920       {
48921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48922       };
48923     } catch (...) {
48924       {
48925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48926       };
48927     }
48928   }
48929
48930 }
48931
48932
48933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
48934   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48935   float arg2 ;
48936   float arg3 ;
48937   float arg4 ;
48938   float arg5 ;
48939   float arg6 ;
48940   float arg7 ;
48941
48942   arg1 = (Dali::CameraActor *)jarg1;
48943   arg2 = (float)jarg2;
48944   arg3 = (float)jarg3;
48945   arg4 = (float)jarg4;
48946   arg5 = (float)jarg5;
48947   arg6 = (float)jarg6;
48948   arg7 = (float)jarg7;
48949   {
48950     try {
48951       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
48952     } catch (std::out_of_range& e) {
48953       {
48954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48955       };
48956     } catch (std::exception& e) {
48957       {
48958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48959       };
48960     } catch (Dali::DaliException e) {
48961       {
48962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48963       };
48964     } catch (...) {
48965       {
48966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48967       };
48968     }
48969   }
48970
48971 }
48972
48973
48974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
48975   void * jresult ;
48976   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48977
48978   {
48979     try {
48980       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
48981     } catch (std::out_of_range& e) {
48982       {
48983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48984       };
48985     } catch (std::exception& e) {
48986       {
48987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48988       };
48989     } catch (Dali::DaliException e) {
48990       {
48991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48992       };
48993     } catch (...) {
48994       {
48995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48996       };
48997     }
48998   }
48999
49000   jresult = (void *)result;
49001   return jresult;
49002 }
49003
49004
49005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49006   void * jresult ;
49007   std::string arg1 ;
49008   Dali::Property::Value arg2 ;
49009   Dali::Property::Value *argp2 ;
49010   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49011
49012   if (!jarg1) {
49013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49014     return 0;
49015   }
49016   (&arg1)->assign(jarg1);
49017   argp2 = (Dali::Property::Value *)jarg2;
49018   if (!argp2) {
49019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49020     return 0;
49021   }
49022   arg2 = *argp2;
49023   {
49024     try {
49025       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49026     } catch (std::out_of_range& e) {
49027       {
49028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49029       };
49030     } catch (std::exception& e) {
49031       {
49032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49033       };
49034     } catch (Dali::DaliException e) {
49035       {
49036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49037       };
49038     } catch (...) {
49039       {
49040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49041       };
49042     }
49043   }
49044
49045   jresult = (void *)result;
49046   return jresult;
49047 }
49048
49049
49050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49051   void * jresult ;
49052   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49053   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49054
49055   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49056   if (!arg1) {
49057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49058     return 0;
49059   }
49060   {
49061     try {
49062       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);
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_StringValuePair_first_set(void * jarg1, char * jarg2) {
49088   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49089   std::string *arg2 = 0 ;
49090
49091   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49092   if (!jarg2) {
49093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49094     return ;
49095   }
49096   std::string arg2_str(jarg2);
49097   arg2 = &arg2_str;
49098   if (arg1) (arg1)->first = *arg2;
49099
49100   //argout typemap for const std::string&
49101
49102 }
49103
49104
49105 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49106   char * jresult ;
49107   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49108   std::string *result = 0 ;
49109
49110   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49111   result = (std::string *) & ((arg1)->first);
49112   jresult = SWIG_csharp_string_callback(result->c_str());
49113   return jresult;
49114 }
49115
49116
49117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49118   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49119   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49120
49121   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49122   arg2 = (Dali::Property::Value *)jarg2;
49123   if (arg1) (arg1)->second = *arg2;
49124 }
49125
49126
49127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49128   void * jresult ;
49129   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49130   Dali::Property::Value *result = 0 ;
49131
49132   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49133   result = (Dali::Property::Value *)& ((arg1)->second);
49134   jresult = (void *)result;
49135   return jresult;
49136 }
49137
49138
49139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49140   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49141
49142   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49143   {
49144     try {
49145       delete arg1;
49146     } catch (std::out_of_range& e) {
49147       {
49148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49149       };
49150     } catch (std::exception& e) {
49151       {
49152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49153       };
49154     } catch (Dali::DaliException e) {
49155       {
49156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49157       };
49158     } catch (...) {
49159       {
49160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49161       };
49162     }
49163   }
49164
49165 }
49166
49167
49168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49169   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49170
49171   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49172   {
49173     try {
49174       (arg1)->clear();
49175     } catch (std::out_of_range& e) {
49176       {
49177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49178       };
49179     } catch (std::exception& e) {
49180       {
49181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49182       };
49183     } catch (Dali::DaliException e) {
49184       {
49185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49186       };
49187     } catch (...) {
49188       {
49189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49190       };
49191     }
49192   }
49193
49194 }
49195
49196
49197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49198   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49199   Dali::TouchPoint *arg2 = 0 ;
49200
49201   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49202   arg2 = (Dali::TouchPoint *)jarg2;
49203   if (!arg2) {
49204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49205     return ;
49206   }
49207   {
49208     try {
49209       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49210     } catch (std::out_of_range& e) {
49211       {
49212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49213       };
49214     } catch (std::exception& e) {
49215       {
49216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49217       };
49218     } catch (Dali::DaliException e) {
49219       {
49220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49221       };
49222     } catch (...) {
49223       {
49224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49225       };
49226     }
49227   }
49228
49229 }
49230
49231
49232 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49233   unsigned long jresult ;
49234   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49235   std::vector< Dali::TouchPoint >::size_type result;
49236
49237   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49238   {
49239     try {
49240       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49241     } catch (std::out_of_range& e) {
49242       {
49243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49244       };
49245     } catch (std::exception& e) {
49246       {
49247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49248       };
49249     } catch (Dali::DaliException e) {
49250       {
49251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49252       };
49253     } catch (...) {
49254       {
49255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49256       };
49257     }
49258   }
49259
49260   jresult = (unsigned long)result;
49261   return jresult;
49262 }
49263
49264
49265 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49266   unsigned long jresult ;
49267   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49268   std::vector< Dali::TouchPoint >::size_type result;
49269
49270   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49271   {
49272     try {
49273       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49274     } catch (std::out_of_range& e) {
49275       {
49276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49277       };
49278     } catch (std::exception& e) {
49279       {
49280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49281       };
49282     } catch (Dali::DaliException e) {
49283       {
49284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49285       };
49286     } catch (...) {
49287       {
49288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49289       };
49290     }
49291   }
49292
49293   jresult = (unsigned long)result;
49294   return jresult;
49295 }
49296
49297
49298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49299   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49300   std::vector< Dali::TouchPoint >::size_type arg2 ;
49301
49302   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49303   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49304   {
49305     try {
49306       (arg1)->reserve(arg2);
49307     } catch (std::out_of_range& e) {
49308       {
49309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49310       };
49311     } catch (std::exception& e) {
49312       {
49313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49314       };
49315     } catch (Dali::DaliException e) {
49316       {
49317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49318       };
49319     } catch (...) {
49320       {
49321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49322       };
49323     }
49324   }
49325
49326 }
49327
49328
49329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49330   void * jresult ;
49331   std::vector< Dali::TouchPoint > *result = 0 ;
49332
49333   {
49334     try {
49335       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49336     } catch (std::out_of_range& e) {
49337       {
49338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49339       };
49340     } catch (std::exception& e) {
49341       {
49342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49343       };
49344     } catch (Dali::DaliException e) {
49345       {
49346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49347       };
49348     } catch (...) {
49349       {
49350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49351       };
49352     }
49353   }
49354
49355   jresult = (void *)result;
49356   return jresult;
49357 }
49358
49359
49360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49361   void * jresult ;
49362   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49363   std::vector< Dali::TouchPoint > *result = 0 ;
49364
49365   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49366   if (!arg1) {
49367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49368     return 0;
49369   }
49370   {
49371     try {
49372       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
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_2(int jarg1) {
49398   void * jresult ;
49399   int arg1 ;
49400   std::vector< Dali::TouchPoint > *result = 0 ;
49401
49402   arg1 = (int)jarg1;
49403   {
49404     try {
49405       try {
49406         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49407       }
49408       catch(std::out_of_range &_e) {
49409         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49410         return 0;
49411       }
49412
49413     } catch (std::out_of_range& e) {
49414       {
49415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49416       };
49417     } catch (std::exception& e) {
49418       {
49419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49420       };
49421     } catch (Dali::DaliException e) {
49422       {
49423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49424       };
49425     } catch (...) {
49426       {
49427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49428       };
49429     }
49430   }
49431
49432   jresult = (void *)result;
49433   return jresult;
49434 }
49435
49436
49437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49438   void * jresult ;
49439   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49440   int arg2 ;
49441   SwigValueWrapper< Dali::TouchPoint > result;
49442
49443   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49444   arg2 = (int)jarg2;
49445   {
49446     try {
49447       try {
49448         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49449       }
49450       catch(std::out_of_range &_e) {
49451         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49452         return 0;
49453       }
49454
49455     } catch (std::out_of_range& e) {
49456       {
49457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49458       };
49459     } catch (std::exception& e) {
49460       {
49461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49462       };
49463     } catch (Dali::DaliException e) {
49464       {
49465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49466       };
49467     } catch (...) {
49468       {
49469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49470       };
49471     }
49472   }
49473
49474   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49475   return jresult;
49476 }
49477
49478
49479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49480   void * jresult ;
49481   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49482   int arg2 ;
49483   Dali::TouchPoint *result = 0 ;
49484
49485   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49486   arg2 = (int)jarg2;
49487   {
49488     try {
49489       try {
49490         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49491       }
49492       catch(std::out_of_range &_e) {
49493         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49494         return 0;
49495       }
49496
49497     } catch (std::out_of_range& e) {
49498       {
49499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49500       };
49501     } catch (std::exception& e) {
49502       {
49503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49504       };
49505     } catch (Dali::DaliException e) {
49506       {
49507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49508       };
49509     } catch (...) {
49510       {
49511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49512       };
49513     }
49514   }
49515
49516   jresult = (void *)result;
49517   return jresult;
49518 }
49519
49520
49521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49522   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49523   int arg2 ;
49524   Dali::TouchPoint *arg3 = 0 ;
49525
49526   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49527   arg2 = (int)jarg2;
49528   arg3 = (Dali::TouchPoint *)jarg3;
49529   if (!arg3) {
49530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49531     return ;
49532   }
49533   {
49534     try {
49535       try {
49536         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49537       }
49538       catch(std::out_of_range &_e) {
49539         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49540         return ;
49541       }
49542
49543     } catch (std::out_of_range& e) {
49544       {
49545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49546       };
49547     } catch (std::exception& e) {
49548       {
49549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49550       };
49551     } catch (Dali::DaliException e) {
49552       {
49553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49554       };
49555     } catch (...) {
49556       {
49557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49558       };
49559     }
49560   }
49561
49562 }
49563
49564
49565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49566   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49567   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49568
49569   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49570   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49571   if (!arg2) {
49572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49573     return ;
49574   }
49575   {
49576     try {
49577       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49578     } catch (std::out_of_range& e) {
49579       {
49580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49581       };
49582     } catch (std::exception& e) {
49583       {
49584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49585       };
49586     } catch (Dali::DaliException e) {
49587       {
49588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49589       };
49590     } catch (...) {
49591       {
49592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49593       };
49594     }
49595   }
49596
49597 }
49598
49599
49600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49601   void * jresult ;
49602   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49603   int arg2 ;
49604   int arg3 ;
49605   std::vector< Dali::TouchPoint > *result = 0 ;
49606
49607   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49608   arg2 = (int)jarg2;
49609   arg3 = (int)jarg3;
49610   {
49611     try {
49612       try {
49613         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49614       }
49615       catch(std::out_of_range &_e) {
49616         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49617         return 0;
49618       }
49619       catch(std::invalid_argument &_e) {
49620         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49621         return 0;
49622       }
49623
49624     } catch (std::out_of_range& e) {
49625       {
49626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49627       };
49628     } catch (std::exception& e) {
49629       {
49630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49631       };
49632     } catch (Dali::DaliException e) {
49633       {
49634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49635       };
49636     } catch (...) {
49637       {
49638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49639       };
49640     }
49641   }
49642
49643   jresult = (void *)result;
49644   return jresult;
49645 }
49646
49647
49648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49649   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49650   int arg2 ;
49651   Dali::TouchPoint *arg3 = 0 ;
49652
49653   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49654   arg2 = (int)jarg2;
49655   arg3 = (Dali::TouchPoint *)jarg3;
49656   if (!arg3) {
49657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49658     return ;
49659   }
49660   {
49661     try {
49662       try {
49663         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49664       }
49665       catch(std::out_of_range &_e) {
49666         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49667         return ;
49668       }
49669
49670     } catch (std::out_of_range& e) {
49671       {
49672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49673       };
49674     } catch (std::exception& e) {
49675       {
49676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49677       };
49678     } catch (Dali::DaliException e) {
49679       {
49680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49681       };
49682     } catch (...) {
49683       {
49684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49685       };
49686     }
49687   }
49688
49689 }
49690
49691
49692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49693   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49694   int arg2 ;
49695   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49696
49697   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49698   arg2 = (int)jarg2;
49699   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49700   if (!arg3) {
49701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49702     return ;
49703   }
49704   {
49705     try {
49706       try {
49707         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49708       }
49709       catch(std::out_of_range &_e) {
49710         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49711         return ;
49712       }
49713
49714     } catch (std::out_of_range& e) {
49715       {
49716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49717       };
49718     } catch (std::exception& e) {
49719       {
49720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49721       };
49722     } catch (Dali::DaliException e) {
49723       {
49724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49725       };
49726     } catch (...) {
49727       {
49728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49729       };
49730     }
49731   }
49732
49733 }
49734
49735
49736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49737   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49738   int arg2 ;
49739
49740   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49741   arg2 = (int)jarg2;
49742   {
49743     try {
49744       try {
49745         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49746       }
49747       catch(std::out_of_range &_e) {
49748         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49749         return ;
49750       }
49751
49752     } catch (std::out_of_range& e) {
49753       {
49754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49755       };
49756     } catch (std::exception& e) {
49757       {
49758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49759       };
49760     } catch (Dali::DaliException e) {
49761       {
49762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49763       };
49764     } catch (...) {
49765       {
49766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49767       };
49768     }
49769   }
49770
49771 }
49772
49773
49774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49775   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49776   int arg2 ;
49777   int arg3 ;
49778
49779   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49780   arg2 = (int)jarg2;
49781   arg3 = (int)jarg3;
49782   {
49783     try {
49784       try {
49785         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49786       }
49787       catch(std::out_of_range &_e) {
49788         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49789         return ;
49790       }
49791       catch(std::invalid_argument &_e) {
49792         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49793         return ;
49794       }
49795
49796     } catch (std::out_of_range& e) {
49797       {
49798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49799       };
49800     } catch (std::exception& e) {
49801       {
49802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49803       };
49804     } catch (Dali::DaliException e) {
49805       {
49806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49807       };
49808     } catch (...) {
49809       {
49810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49811       };
49812     }
49813   }
49814
49815 }
49816
49817
49818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49819   void * jresult ;
49820   Dali::TouchPoint *arg1 = 0 ;
49821   int arg2 ;
49822   std::vector< Dali::TouchPoint > *result = 0 ;
49823
49824   arg1 = (Dali::TouchPoint *)jarg1;
49825   if (!arg1) {
49826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49827     return 0;
49828   }
49829   arg2 = (int)jarg2;
49830   {
49831     try {
49832       try {
49833         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49834       }
49835       catch(std::out_of_range &_e) {
49836         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49837         return 0;
49838       }
49839
49840     } catch (std::out_of_range& e) {
49841       {
49842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49843       };
49844     } catch (std::exception& e) {
49845       {
49846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49847       };
49848     } catch (Dali::DaliException e) {
49849       {
49850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49851       };
49852     } catch (...) {
49853       {
49854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49855       };
49856     }
49857   }
49858
49859   jresult = (void *)result;
49860   return jresult;
49861 }
49862
49863
49864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49865   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49866
49867   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49868   {
49869     try {
49870       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49871     } catch (std::out_of_range& e) {
49872       {
49873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49874       };
49875     } catch (std::exception& e) {
49876       {
49877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49878       };
49879     } catch (Dali::DaliException e) {
49880       {
49881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49882       };
49883     } catch (...) {
49884       {
49885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49886       };
49887     }
49888   }
49889
49890 }
49891
49892
49893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49894   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49895   int arg2 ;
49896   int arg3 ;
49897
49898   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49899   arg2 = (int)jarg2;
49900   arg3 = (int)jarg3;
49901   {
49902     try {
49903       try {
49904         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49905       }
49906       catch(std::out_of_range &_e) {
49907         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49908         return ;
49909       }
49910       catch(std::invalid_argument &_e) {
49911         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49912         return ;
49913       }
49914
49915     } catch (std::out_of_range& e) {
49916       {
49917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49918       };
49919     } catch (std::exception& e) {
49920       {
49921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49922       };
49923     } catch (Dali::DaliException e) {
49924       {
49925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49926       };
49927     } catch (...) {
49928       {
49929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49930       };
49931     }
49932   }
49933
49934 }
49935
49936
49937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
49938   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49939   int arg2 ;
49940   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49941
49942   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49943   arg2 = (int)jarg2;
49944   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49945   if (!arg3) {
49946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49947     return ;
49948   }
49949   {
49950     try {
49951       try {
49952         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49953       }
49954       catch(std::out_of_range &_e) {
49955         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49956         return ;
49957       }
49958
49959     } catch (std::out_of_range& e) {
49960       {
49961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49962       };
49963     } catch (std::exception& e) {
49964       {
49965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49966       };
49967     } catch (Dali::DaliException e) {
49968       {
49969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49970       };
49971     } catch (...) {
49972       {
49973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49974       };
49975     }
49976   }
49977
49978 }
49979
49980
49981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
49982   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49983
49984   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49985   {
49986     try {
49987       delete arg1;
49988     } catch (std::out_of_range& e) {
49989       {
49990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49991       };
49992     } catch (std::exception& e) {
49993       {
49994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49995       };
49996     } catch (Dali::DaliException e) {
49997       {
49998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49999       };
50000     } catch (...) {
50001       {
50002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50003       };
50004     }
50005   }
50006
50007 }
50008
50009
50010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50011   void * jresult ;
50012   Dali::Rect< int > *result = 0 ;
50013
50014   {
50015     try {
50016       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50017     } catch (std::out_of_range& e) {
50018       {
50019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50020       };
50021     } catch (std::exception& e) {
50022       {
50023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50024       };
50025     } catch (Dali::DaliException e) {
50026       {
50027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50028       };
50029     } catch (...) {
50030       {
50031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50032       };
50033     }
50034   }
50035
50036   jresult = (void *)result;
50037   return jresult;
50038 }
50039
50040
50041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50042   void * jresult ;
50043   int arg1 ;
50044   int arg2 ;
50045   int arg3 ;
50046   int arg4 ;
50047   Dali::Rect< int > *result = 0 ;
50048
50049   arg1 = (int)jarg1;
50050   arg2 = (int)jarg2;
50051   arg3 = (int)jarg3;
50052   arg4 = (int)jarg4;
50053   {
50054     try {
50055       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50056     } catch (std::out_of_range& e) {
50057       {
50058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50059       };
50060     } catch (std::exception& e) {
50061       {
50062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50063       };
50064     } catch (Dali::DaliException e) {
50065       {
50066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50067       };
50068     } catch (...) {
50069       {
50070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50071       };
50072     }
50073   }
50074
50075   jresult = (void *)result;
50076   return jresult;
50077 }
50078
50079
50080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50081   void * jresult ;
50082   Dali::Rect< int > *arg1 = 0 ;
50083   Dali::Rect< int > *result = 0 ;
50084
50085   arg1 = (Dali::Rect< int > *)jarg1;
50086   if (!arg1) {
50087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50088     return 0;
50089   }
50090   {
50091     try {
50092       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
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_Rectangle_Assign(void * jarg1, void * jarg2) {
50118   void * jresult ;
50119   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50120   Dali::Rect< int > *arg2 = 0 ;
50121   Dali::Rect< int > *result = 0 ;
50122
50123   arg1 = (Dali::Rect< int > *)jarg1;
50124   arg2 = (Dali::Rect< int > *)jarg2;
50125   if (!arg2) {
50126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50127     return 0;
50128   }
50129   {
50130     try {
50131       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50132     } catch (std::out_of_range& e) {
50133       {
50134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50135       };
50136     } catch (std::exception& e) {
50137       {
50138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50139       };
50140     } catch (Dali::DaliException e) {
50141       {
50142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50143       };
50144     } catch (...) {
50145       {
50146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50147       };
50148     }
50149   }
50150
50151   jresult = (void *)result;
50152   return jresult;
50153 }
50154
50155
50156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50157   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50158   int arg2 ;
50159   int arg3 ;
50160   int arg4 ;
50161   int arg5 ;
50162
50163   arg1 = (Dali::Rect< int > *)jarg1;
50164   arg2 = (int)jarg2;
50165   arg3 = (int)jarg3;
50166   arg4 = (int)jarg4;
50167   arg5 = (int)jarg5;
50168   {
50169     try {
50170       (arg1)->Set(arg2,arg3,arg4,arg5);
50171     } catch (std::out_of_range& e) {
50172       {
50173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50174       };
50175     } catch (std::exception& e) {
50176       {
50177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50178       };
50179     } catch (Dali::DaliException e) {
50180       {
50181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50182       };
50183     } catch (...) {
50184       {
50185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50186       };
50187     }
50188   }
50189
50190 }
50191
50192
50193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50194   unsigned int jresult ;
50195   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50196   bool result;
50197
50198   arg1 = (Dali::Rect< int > *)jarg1;
50199   {
50200     try {
50201       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50202     } catch (std::out_of_range& e) {
50203       {
50204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50205       };
50206     } catch (std::exception& e) {
50207       {
50208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50209       };
50210     } catch (Dali::DaliException e) {
50211       {
50212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50213       };
50214     } catch (...) {
50215       {
50216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50217       };
50218     }
50219   }
50220
50221   jresult = result;
50222   return jresult;
50223 }
50224
50225
50226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50227   int jresult ;
50228   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50229   int result;
50230
50231   arg1 = (Dali::Rect< int > *)jarg1;
50232   {
50233     try {
50234       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50235     } catch (std::out_of_range& e) {
50236       {
50237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50238       };
50239     } catch (std::exception& e) {
50240       {
50241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50242       };
50243     } catch (Dali::DaliException e) {
50244       {
50245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50246       };
50247     } catch (...) {
50248       {
50249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50250       };
50251     }
50252   }
50253
50254   jresult = result;
50255   return jresult;
50256 }
50257
50258
50259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50260   int jresult ;
50261   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50262   int result;
50263
50264   arg1 = (Dali::Rect< int > *)jarg1;
50265   {
50266     try {
50267       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50268     } catch (std::out_of_range& e) {
50269       {
50270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50271       };
50272     } catch (std::exception& e) {
50273       {
50274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50275       };
50276     } catch (Dali::DaliException e) {
50277       {
50278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50279       };
50280     } catch (...) {
50281       {
50282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50283       };
50284     }
50285   }
50286
50287   jresult = result;
50288   return jresult;
50289 }
50290
50291
50292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50293   int jresult ;
50294   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50295   int result;
50296
50297   arg1 = (Dali::Rect< int > *)jarg1;
50298   {
50299     try {
50300       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50301     } catch (std::out_of_range& e) {
50302       {
50303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50304       };
50305     } catch (std::exception& e) {
50306       {
50307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50308       };
50309     } catch (Dali::DaliException e) {
50310       {
50311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50312       };
50313     } catch (...) {
50314       {
50315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50316       };
50317     }
50318   }
50319
50320   jresult = result;
50321   return jresult;
50322 }
50323
50324
50325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50326   int jresult ;
50327   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50328   int result;
50329
50330   arg1 = (Dali::Rect< int > *)jarg1;
50331   {
50332     try {
50333       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50334     } catch (std::out_of_range& e) {
50335       {
50336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50337       };
50338     } catch (std::exception& e) {
50339       {
50340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50341       };
50342     } catch (Dali::DaliException e) {
50343       {
50344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50345       };
50346     } catch (...) {
50347       {
50348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50349       };
50350     }
50351   }
50352
50353   jresult = result;
50354   return jresult;
50355 }
50356
50357
50358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50359   int jresult ;
50360   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50361   int result;
50362
50363   arg1 = (Dali::Rect< int > *)jarg1;
50364   {
50365     try {
50366       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50367     } catch (std::out_of_range& e) {
50368       {
50369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50370       };
50371     } catch (std::exception& e) {
50372       {
50373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50374       };
50375     } catch (Dali::DaliException e) {
50376       {
50377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50378       };
50379     } catch (...) {
50380       {
50381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50382       };
50383     }
50384   }
50385
50386   jresult = result;
50387   return jresult;
50388 }
50389
50390
50391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50392   unsigned int jresult ;
50393   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50394   Dali::Rect< int > *arg2 = 0 ;
50395   bool result;
50396
50397   arg1 = (Dali::Rect< int > *)jarg1;
50398   arg2 = (Dali::Rect< int > *)jarg2;
50399   if (!arg2) {
50400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50401     return 0;
50402   }
50403   {
50404     try {
50405       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50406     } catch (std::out_of_range& e) {
50407       {
50408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50409       };
50410     } catch (std::exception& e) {
50411       {
50412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50413       };
50414     } catch (Dali::DaliException e) {
50415       {
50416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50417       };
50418     } catch (...) {
50419       {
50420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50421       };
50422     }
50423   }
50424
50425   jresult = result;
50426   return jresult;
50427 }
50428
50429
50430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50431   unsigned int jresult ;
50432   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50433   Dali::Rect< int > *arg2 = 0 ;
50434   bool result;
50435
50436   arg1 = (Dali::Rect< int > *)jarg1;
50437   arg2 = (Dali::Rect< int > *)jarg2;
50438   if (!arg2) {
50439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50440     return 0;
50441   }
50442   {
50443     try {
50444       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50445     } catch (std::out_of_range& e) {
50446       {
50447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50448       };
50449     } catch (std::exception& e) {
50450       {
50451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50452       };
50453     } catch (Dali::DaliException e) {
50454       {
50455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50456       };
50457     } catch (...) {
50458       {
50459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50460       };
50461     }
50462   }
50463
50464   jresult = result;
50465   return jresult;
50466 }
50467
50468
50469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50470   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50471   int arg2 ;
50472
50473   arg1 = (Dali::Rect< int > *)jarg1;
50474   arg2 = (int)jarg2;
50475   if (arg1) (arg1)->x = arg2;
50476 }
50477
50478
50479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50480   int jresult ;
50481   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50482   int result;
50483
50484   arg1 = (Dali::Rect< int > *)jarg1;
50485   result = (int) ((arg1)->x);
50486   jresult = result;
50487   return jresult;
50488 }
50489
50490
50491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50492   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50493   int arg2 ;
50494
50495   arg1 = (Dali::Rect< int > *)jarg1;
50496   arg2 = (int)jarg2;
50497   if (arg1) (arg1)->left = arg2;
50498 }
50499
50500
50501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50502   int jresult ;
50503   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50504   int result;
50505
50506   arg1 = (Dali::Rect< int > *)jarg1;
50507   result = (int) ((arg1)->left);
50508   jresult = result;
50509   return jresult;
50510 }
50511
50512
50513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50514   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50515   int arg2 ;
50516
50517   arg1 = (Dali::Rect< int > *)jarg1;
50518   arg2 = (int)jarg2;
50519   if (arg1) (arg1)->y = arg2;
50520 }
50521
50522
50523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50524   int jresult ;
50525   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50526   int result;
50527
50528   arg1 = (Dali::Rect< int > *)jarg1;
50529   result = (int) ((arg1)->y);
50530   jresult = result;
50531   return jresult;
50532 }
50533
50534
50535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50536   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50537   int arg2 ;
50538
50539   arg1 = (Dali::Rect< int > *)jarg1;
50540   arg2 = (int)jarg2;
50541   if (arg1) (arg1)->right = arg2;
50542 }
50543
50544
50545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50546   int jresult ;
50547   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50548   int result;
50549
50550   arg1 = (Dali::Rect< int > *)jarg1;
50551   result = (int) ((arg1)->right);
50552   jresult = result;
50553   return jresult;
50554 }
50555
50556
50557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50558   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50559   int arg2 ;
50560
50561   arg1 = (Dali::Rect< int > *)jarg1;
50562   arg2 = (int)jarg2;
50563   if (arg1) (arg1)->width = arg2;
50564 }
50565
50566
50567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50568   int jresult ;
50569   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50570   int result;
50571
50572   arg1 = (Dali::Rect< int > *)jarg1;
50573   result = (int) ((arg1)->width);
50574   jresult = result;
50575   return jresult;
50576 }
50577
50578
50579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50580   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50581   int arg2 ;
50582
50583   arg1 = (Dali::Rect< int > *)jarg1;
50584   arg2 = (int)jarg2;
50585   if (arg1) (arg1)->bottom = arg2;
50586 }
50587
50588
50589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50590   int jresult ;
50591   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50592   int result;
50593
50594   arg1 = (Dali::Rect< int > *)jarg1;
50595   result = (int) ((arg1)->bottom);
50596   jresult = result;
50597   return jresult;
50598 }
50599
50600
50601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50602   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50603   int arg2 ;
50604
50605   arg1 = (Dali::Rect< int > *)jarg1;
50606   arg2 = (int)jarg2;
50607   if (arg1) (arg1)->height = arg2;
50608 }
50609
50610
50611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50612   int jresult ;
50613   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50614   int result;
50615
50616   arg1 = (Dali::Rect< int > *)jarg1;
50617   result = (int) ((arg1)->height);
50618   jresult = result;
50619   return jresult;
50620 }
50621
50622
50623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50624   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50625   int arg2 ;
50626
50627   arg1 = (Dali::Rect< int > *)jarg1;
50628   arg2 = (int)jarg2;
50629   if (arg1) (arg1)->top = arg2;
50630 }
50631
50632
50633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50634   int jresult ;
50635   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50636   int result;
50637
50638   arg1 = (Dali::Rect< int > *)jarg1;
50639   result = (int) ((arg1)->top);
50640   jresult = result;
50641   return jresult;
50642 }
50643
50644
50645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50646   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50647
50648   arg1 = (Dali::Rect< int > *)jarg1;
50649   {
50650     try {
50651       delete arg1;
50652     } catch (std::out_of_range& e) {
50653       {
50654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50655       };
50656     } catch (std::exception& e) {
50657       {
50658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50659       };
50660     } catch (Dali::DaliException e) {
50661       {
50662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50663       };
50664     } catch (...) {
50665       {
50666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50667       };
50668     }
50669   }
50670
50671 }
50672
50673
50674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50675   void * jresult ;
50676   Dali::Rect< float > *result = 0 ;
50677
50678   {
50679     try {
50680       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50681     } catch (std::out_of_range& e) {
50682       {
50683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50684       };
50685     } catch (std::exception& e) {
50686       {
50687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50688       };
50689     } catch (Dali::DaliException e) {
50690       {
50691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50692       };
50693     } catch (...) {
50694       {
50695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50696       };
50697     }
50698   }
50699
50700   jresult = (void *)result;
50701   return jresult;
50702 }
50703
50704
50705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50706   void * jresult ;
50707   float arg1 ;
50708   float arg2 ;
50709   float arg3 ;
50710   float arg4 ;
50711   Dali::Rect< float > *result = 0 ;
50712
50713   arg1 = (float)jarg1;
50714   arg2 = (float)jarg2;
50715   arg3 = (float)jarg4;
50716   arg4 = (float)jarg3;
50717   {
50718     try {
50719       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50720     } catch (std::out_of_range& e) {
50721       {
50722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50723       };
50724     } catch (std::exception& e) {
50725       {
50726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50727       };
50728     } catch (Dali::DaliException e) {
50729       {
50730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50731       };
50732     } catch (...) {
50733       {
50734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50735       };
50736     }
50737   }
50738
50739   jresult = (void *)result;
50740   return jresult;
50741 }
50742
50743
50744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50745   void * jresult ;
50746   Dali::Rect< float > *arg1 = 0 ;
50747   Dali::Rect< float > *result = 0 ;
50748
50749   arg1 = (Dali::Rect< float > *)jarg1;
50750   if (!arg1) {
50751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50752     return 0;
50753   }
50754   {
50755     try {
50756       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
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_PaddingType_Assign(void * jarg1, void * jarg2) {
50782   void * jresult ;
50783   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50784   Dali::Rect< float > *arg2 = 0 ;
50785   Dali::Rect< float > *result = 0 ;
50786
50787   arg1 = (Dali::Rect< float > *)jarg1;
50788   arg2 = (Dali::Rect< float > *)jarg2;
50789   if (!arg2) {
50790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50791     return 0;
50792   }
50793   {
50794     try {
50795       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50796     } catch (std::out_of_range& e) {
50797       {
50798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50799       };
50800     } catch (std::exception& e) {
50801       {
50802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50803       };
50804     } catch (Dali::DaliException e) {
50805       {
50806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50807       };
50808     } catch (...) {
50809       {
50810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50811       };
50812     }
50813   }
50814
50815   jresult = (void *)result;
50816   return jresult;
50817 }
50818
50819
50820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50821   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50822   float arg2 ;
50823   float arg3 ;
50824   float arg4 ;
50825   float arg5 ;
50826
50827   arg1 = (Dali::Rect< float > *)jarg1;
50828   arg2 = (float)jarg2;
50829   arg3 = (float)jarg3;
50830   arg4 = (float)jarg5;
50831   arg5 = (float)jarg4;
50832   {
50833     try {
50834       (arg1)->Set(arg2,arg3,arg4,arg5);
50835     } catch (std::out_of_range& e) {
50836       {
50837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50838       };
50839     } catch (std::exception& e) {
50840       {
50841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50842       };
50843     } catch (Dali::DaliException e) {
50844       {
50845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50846       };
50847     } catch (...) {
50848       {
50849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50850       };
50851     }
50852   }
50853
50854 }
50855
50856
50857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50858   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50859   float arg2 ;
50860
50861   arg1 = (Dali::Rect< float > *)jarg1;
50862   arg2 = (float)jarg2;
50863   if (arg1) (arg1)->left = arg2;
50864 }
50865
50866
50867 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50868   float jresult ;
50869   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50870   float result;
50871
50872   arg1 = (Dali::Rect< float > *)jarg1;
50873   result = (float) ((arg1)->left);
50874   jresult = result;
50875   return jresult;
50876 }
50877
50878
50879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50880   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50881   float arg2 ;
50882
50883   arg1 = (Dali::Rect< float > *)jarg1;
50884   arg2 = (float)jarg2;
50885   if (arg1) (arg1)->left = arg2;
50886 }
50887
50888
50889 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50890   float jresult ;
50891   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50892   float result;
50893
50894   arg1 = (Dali::Rect< float > *)jarg1;
50895   result = (float) ((arg1)->left);
50896   jresult = result;
50897   return jresult;
50898 }
50899
50900
50901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50902   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50903   float arg2 ;
50904
50905   arg1 = (Dali::Rect< float > *)jarg1;
50906   arg2 = (float)jarg2;
50907   if (arg1) (arg1)->right = arg2;
50908 }
50909
50910
50911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50912   float jresult ;
50913   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50914   float result;
50915
50916   arg1 = (Dali::Rect< float > *)jarg1;
50917   result = (float) ((arg1)->right);
50918   jresult = result;
50919   return jresult;
50920 }
50921
50922
50923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
50924   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50925   float arg2 ;
50926
50927   arg1 = (Dali::Rect< float > *)jarg1;
50928   arg2 = (float)jarg2;
50929   if (arg1) (arg1)->right = arg2;
50930 }
50931
50932
50933 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
50934   float jresult ;
50935   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50936   float result;
50937
50938   arg1 = (Dali::Rect< float > *)jarg1;
50939   result = (float) ((arg1)->right);
50940   jresult = result;
50941   return jresult;
50942 }
50943
50944
50945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
50946   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50947   float arg2 ;
50948
50949   arg1 = (Dali::Rect< float > *)jarg1;
50950   arg2 = (float)jarg2;
50951   if (arg1) (arg1)->bottom = arg2;
50952 }
50953
50954
50955 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
50956   float jresult ;
50957   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50958   float result;
50959
50960   arg1 = (Dali::Rect< float > *)jarg1;
50961   result = (float) ((arg1)->bottom);
50962   jresult = result;
50963   return jresult;
50964 }
50965
50966
50967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
50968   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50969   float arg2 ;
50970
50971   arg1 = (Dali::Rect< float > *)jarg1;
50972   arg2 = (float)jarg2;
50973   if (arg1) (arg1)->top = arg2;
50974 }
50975
50976
50977 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
50978   float jresult ;
50979   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50980   float result;
50981
50982   arg1 = (Dali::Rect< float > *)jarg1;
50983   result = (float) ((arg1)->top);
50984   jresult = result;
50985   return jresult;
50986 }
50987
50988
50989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
50990   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50991
50992   arg1 = (Dali::Rect< float > *)jarg1;
50993   {
50994     try {
50995       delete arg1;
50996     } catch (std::out_of_range& e) {
50997       {
50998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50999       };
51000     } catch (std::exception& e) {
51001       {
51002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51003       };
51004     } catch (Dali::DaliException e) {
51005       {
51006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51007       };
51008     } catch (...) {
51009       {
51010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51011       };
51012     }
51013   }
51014
51015 }
51016
51017
51018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51019   int jresult ;
51020   int result;
51021
51022   result = (int)Dali::Vector< int >::BaseType;
51023   jresult = (int)result;
51024   return jresult;
51025 }
51026
51027
51028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51029   void * jresult ;
51030   Dali::Vector< int > *result = 0 ;
51031
51032   {
51033     try {
51034       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51035     } catch (std::out_of_range& e) {
51036       {
51037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51038       };
51039     } catch (std::exception& e) {
51040       {
51041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51042       };
51043     } catch (Dali::DaliException e) {
51044       {
51045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51046       };
51047     } catch (...) {
51048       {
51049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51050       };
51051     }
51052   }
51053
51054   jresult = (void *)result;
51055   return jresult;
51056 }
51057
51058
51059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51060   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51061
51062   arg1 = (Dali::Vector< int > *)jarg1;
51063   {
51064     try {
51065       delete arg1;
51066     } catch (std::out_of_range& e) {
51067       {
51068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51069       };
51070     } catch (std::exception& e) {
51071       {
51072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51073       };
51074     } catch (Dali::DaliException e) {
51075       {
51076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51077       };
51078     } catch (...) {
51079       {
51080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51081       };
51082     }
51083   }
51084
51085 }
51086
51087
51088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51089   void * jresult ;
51090   Dali::Vector< int > *arg1 = 0 ;
51091   Dali::Vector< int > *result = 0 ;
51092
51093   arg1 = (Dali::Vector< int > *)jarg1;
51094   if (!arg1) {
51095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51096     return 0;
51097   }
51098   {
51099     try {
51100       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51101     } catch (std::out_of_range& e) {
51102       {
51103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51104       };
51105     } catch (std::exception& e) {
51106       {
51107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51108       };
51109     } catch (Dali::DaliException e) {
51110       {
51111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51112       };
51113     } catch (...) {
51114       {
51115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51116       };
51117     }
51118   }
51119
51120   jresult = (void *)result;
51121   return jresult;
51122 }
51123
51124
51125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51126   void * jresult ;
51127   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51128   Dali::Vector< int > *arg2 = 0 ;
51129   Dali::Vector< int > *result = 0 ;
51130
51131   arg1 = (Dali::Vector< int > *)jarg1;
51132   arg2 = (Dali::Vector< int > *)jarg2;
51133   if (!arg2) {
51134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51135     return 0;
51136   }
51137   {
51138     try {
51139       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51140     } catch (std::out_of_range& e) {
51141       {
51142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51143       };
51144     } catch (std::exception& e) {
51145       {
51146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51147       };
51148     } catch (Dali::DaliException e) {
51149       {
51150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51151       };
51152     } catch (...) {
51153       {
51154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51155       };
51156     }
51157   }
51158
51159   jresult = (void *)result;
51160   return jresult;
51161 }
51162
51163
51164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51165   void * jresult ;
51166   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51167   Dali::Vector< int >::Iterator result;
51168
51169   arg1 = (Dali::Vector< int > *)jarg1;
51170   {
51171     try {
51172       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51173     } catch (std::out_of_range& e) {
51174       {
51175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51176       };
51177     } catch (std::exception& e) {
51178       {
51179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51180       };
51181     } catch (Dali::DaliException e) {
51182       {
51183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51184       };
51185     } catch (...) {
51186       {
51187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51188       };
51189     }
51190   }
51191
51192   jresult = (void *)result;
51193   return jresult;
51194 }
51195
51196
51197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51198   void * jresult ;
51199   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51200   Dali::Vector< int >::Iterator result;
51201
51202   arg1 = (Dali::Vector< int > *)jarg1;
51203   {
51204     try {
51205       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51206     } catch (std::out_of_range& e) {
51207       {
51208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51209       };
51210     } catch (std::exception& e) {
51211       {
51212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51213       };
51214     } catch (Dali::DaliException e) {
51215       {
51216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51217       };
51218     } catch (...) {
51219       {
51220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51221       };
51222     }
51223   }
51224
51225   jresult = (void *)result;
51226   return jresult;
51227 }
51228
51229
51230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51231   void * jresult ;
51232   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51233   Dali::Vector< int >::SizeType arg2 ;
51234   Dali::Vector< int >::ItemType *result = 0 ;
51235
51236   arg1 = (Dali::Vector< int > *)jarg1;
51237   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51238   {
51239     try {
51240       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51241     } catch (std::out_of_range& e) {
51242       {
51243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51244       };
51245     } catch (std::exception& e) {
51246       {
51247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51248       };
51249     } catch (Dali::DaliException e) {
51250       {
51251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51252       };
51253     } catch (...) {
51254       {
51255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51256       };
51257     }
51258   }
51259
51260   jresult = (void *)result;
51261   return jresult;
51262 }
51263
51264
51265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51266   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51267   Dali::Vector< int >::ItemType *arg2 = 0 ;
51268   Dali::Vector< int >::ItemType temp2 ;
51269
51270   arg1 = (Dali::Vector< int > *)jarg1;
51271   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51272   arg2 = &temp2;
51273   {
51274     try {
51275       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51276     } catch (std::out_of_range& e) {
51277       {
51278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51279       };
51280     } catch (std::exception& e) {
51281       {
51282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51283       };
51284     } catch (Dali::DaliException e) {
51285       {
51286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51287       };
51288     } catch (...) {
51289       {
51290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51291       };
51292     }
51293   }
51294
51295 }
51296
51297
51298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51299   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51300   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51301   Dali::Vector< int >::ItemType *arg3 = 0 ;
51302   Dali::Vector< int >::ItemType temp3 ;
51303
51304   arg1 = (Dali::Vector< int > *)jarg1;
51305   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51306   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51307   arg3 = &temp3;
51308   {
51309     try {
51310       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51311     } catch (std::out_of_range& e) {
51312       {
51313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51314       };
51315     } catch (std::exception& e) {
51316       {
51317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51318       };
51319     } catch (Dali::DaliException e) {
51320       {
51321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51322       };
51323     } catch (...) {
51324       {
51325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51326       };
51327     }
51328   }
51329
51330 }
51331
51332
51333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51334   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51335   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51336   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51337   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51338
51339   arg1 = (Dali::Vector< int > *)jarg1;
51340   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51341   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51342   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51343   {
51344     try {
51345       (arg1)->Insert(arg2,arg3,arg4);
51346     } catch (std::out_of_range& e) {
51347       {
51348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51349       };
51350     } catch (std::exception& e) {
51351       {
51352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51353       };
51354     } catch (Dali::DaliException e) {
51355       {
51356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51357       };
51358     } catch (...) {
51359       {
51360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51361       };
51362     }
51363   }
51364
51365 }
51366
51367
51368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51369   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51370   Dali::Vector< int >::SizeType arg2 ;
51371
51372   arg1 = (Dali::Vector< int > *)jarg1;
51373   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51374   {
51375     try {
51376       (arg1)->Reserve(arg2);
51377     } catch (std::out_of_range& e) {
51378       {
51379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51380       };
51381     } catch (std::exception& e) {
51382       {
51383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51384       };
51385     } catch (Dali::DaliException e) {
51386       {
51387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51388       };
51389     } catch (...) {
51390       {
51391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51392       };
51393     }
51394   }
51395
51396 }
51397
51398
51399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51400   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51401   Dali::Vector< int >::SizeType arg2 ;
51402
51403   arg1 = (Dali::Vector< int > *)jarg1;
51404   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51405   {
51406     try {
51407       (arg1)->Resize(arg2);
51408     } catch (std::out_of_range& e) {
51409       {
51410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51411       };
51412     } catch (std::exception& e) {
51413       {
51414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51415       };
51416     } catch (Dali::DaliException e) {
51417       {
51418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51419       };
51420     } catch (...) {
51421       {
51422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51423       };
51424     }
51425   }
51426
51427 }
51428
51429
51430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51431   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51432   Dali::Vector< int >::SizeType arg2 ;
51433   Dali::Vector< int >::ItemType *arg3 = 0 ;
51434   Dali::Vector< int >::ItemType temp3 ;
51435
51436   arg1 = (Dali::Vector< int > *)jarg1;
51437   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51438   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51439   arg3 = &temp3;
51440   {
51441     try {
51442       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51443     } catch (std::out_of_range& e) {
51444       {
51445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51446       };
51447     } catch (std::exception& e) {
51448       {
51449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51450       };
51451     } catch (Dali::DaliException e) {
51452       {
51453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51454       };
51455     } catch (...) {
51456       {
51457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51458       };
51459     }
51460   }
51461
51462 }
51463
51464
51465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51466   void * jresult ;
51467   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51468   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51469   Dali::Vector< int >::Iterator result;
51470
51471   arg1 = (Dali::Vector< int > *)jarg1;
51472   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51473   {
51474     try {
51475       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51476     } catch (std::out_of_range& e) {
51477       {
51478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51479       };
51480     } catch (std::exception& e) {
51481       {
51482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51483       };
51484     } catch (Dali::DaliException e) {
51485       {
51486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51487       };
51488     } catch (...) {
51489       {
51490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51491       };
51492     }
51493   }
51494
51495   jresult = (void *)result;
51496   return jresult;
51497 }
51498
51499
51500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51501   void * jresult ;
51502   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51503   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51504   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51505   Dali::Vector< int >::Iterator result;
51506
51507   arg1 = (Dali::Vector< int > *)jarg1;
51508   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51509   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51510   {
51511     try {
51512       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
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_Remove(void * jarg1, void * jarg2) {
51538   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51539   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51540
51541   arg1 = (Dali::Vector< int > *)jarg1;
51542   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51543   {
51544     try {
51545       (arg1)->Remove(arg2);
51546     } catch (std::out_of_range& e) {
51547       {
51548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51549       };
51550     } catch (std::exception& e) {
51551       {
51552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51553       };
51554     } catch (Dali::DaliException e) {
51555       {
51556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51557       };
51558     } catch (...) {
51559       {
51560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51561       };
51562     }
51563   }
51564
51565 }
51566
51567
51568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51569   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51570   Dali::Vector< int > *arg2 = 0 ;
51571
51572   arg1 = (Dali::Vector< int > *)jarg1;
51573   arg2 = (Dali::Vector< int > *)jarg2;
51574   if (!arg2) {
51575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51576     return ;
51577   }
51578   {
51579     try {
51580       (arg1)->Swap(*arg2);
51581     } catch (std::out_of_range& e) {
51582       {
51583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51584       };
51585     } catch (std::exception& e) {
51586       {
51587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51588       };
51589     } catch (Dali::DaliException e) {
51590       {
51591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51592       };
51593     } catch (...) {
51594       {
51595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51596       };
51597     }
51598   }
51599
51600 }
51601
51602
51603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51604   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51605
51606   arg1 = (Dali::Vector< int > *)jarg1;
51607   {
51608     try {
51609       (arg1)->Clear();
51610     } catch (std::out_of_range& e) {
51611       {
51612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51613       };
51614     } catch (std::exception& e) {
51615       {
51616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51617       };
51618     } catch (Dali::DaliException e) {
51619       {
51620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51621       };
51622     } catch (...) {
51623       {
51624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51625       };
51626     }
51627   }
51628
51629 }
51630
51631
51632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51633   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51634
51635   arg1 = (Dali::Vector< int > *)jarg1;
51636   {
51637     try {
51638       (arg1)->Release();
51639     } catch (std::out_of_range& e) {
51640       {
51641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51642       };
51643     } catch (std::exception& e) {
51644       {
51645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51646       };
51647     } catch (Dali::DaliException e) {
51648       {
51649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51650       };
51651     } catch (...) {
51652       {
51653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51654       };
51655     }
51656   }
51657
51658 }
51659
51660
51661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51662   int jresult ;
51663   int result;
51664
51665   result = (int)Dali::Vector< float >::BaseType;
51666   jresult = (int)result;
51667   return jresult;
51668 }
51669
51670
51671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51672   void * jresult ;
51673   Dali::Vector< float > *result = 0 ;
51674
51675   {
51676     try {
51677       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51678     } catch (std::out_of_range& e) {
51679       {
51680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51681       };
51682     } catch (std::exception& e) {
51683       {
51684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51685       };
51686     } catch (Dali::DaliException e) {
51687       {
51688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51689       };
51690     } catch (...) {
51691       {
51692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51693       };
51694     }
51695   }
51696
51697   jresult = (void *)result;
51698   return jresult;
51699 }
51700
51701
51702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51703   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51704
51705   arg1 = (Dali::Vector< float > *)jarg1;
51706   {
51707     try {
51708       delete arg1;
51709     } catch (std::out_of_range& e) {
51710       {
51711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51712       };
51713     } catch (std::exception& e) {
51714       {
51715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51716       };
51717     } catch (Dali::DaliException e) {
51718       {
51719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51720       };
51721     } catch (...) {
51722       {
51723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51724       };
51725     }
51726   }
51727
51728 }
51729
51730
51731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51732   void * jresult ;
51733   Dali::Vector< float > *arg1 = 0 ;
51734   Dali::Vector< float > *result = 0 ;
51735
51736   arg1 = (Dali::Vector< float > *)jarg1;
51737   if (!arg1) {
51738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51739     return 0;
51740   }
51741   {
51742     try {
51743       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51744     } catch (std::out_of_range& e) {
51745       {
51746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51747       };
51748     } catch (std::exception& e) {
51749       {
51750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51751       };
51752     } catch (Dali::DaliException e) {
51753       {
51754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51755       };
51756     } catch (...) {
51757       {
51758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51759       };
51760     }
51761   }
51762
51763   jresult = (void *)result;
51764   return jresult;
51765 }
51766
51767
51768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51769   void * jresult ;
51770   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51771   Dali::Vector< float > *arg2 = 0 ;
51772   Dali::Vector< float > *result = 0 ;
51773
51774   arg1 = (Dali::Vector< float > *)jarg1;
51775   arg2 = (Dali::Vector< float > *)jarg2;
51776   if (!arg2) {
51777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51778     return 0;
51779   }
51780   {
51781     try {
51782       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51783     } catch (std::out_of_range& e) {
51784       {
51785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51786       };
51787     } catch (std::exception& e) {
51788       {
51789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51790       };
51791     } catch (Dali::DaliException e) {
51792       {
51793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51794       };
51795     } catch (...) {
51796       {
51797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51798       };
51799     }
51800   }
51801
51802   jresult = (void *)result;
51803   return jresult;
51804 }
51805
51806
51807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51808   void * jresult ;
51809   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51810   Dali::Vector< float >::Iterator result;
51811
51812   arg1 = (Dali::Vector< float > *)jarg1;
51813   {
51814     try {
51815       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51816     } catch (std::out_of_range& e) {
51817       {
51818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51819       };
51820     } catch (std::exception& e) {
51821       {
51822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51823       };
51824     } catch (Dali::DaliException e) {
51825       {
51826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51827       };
51828     } catch (...) {
51829       {
51830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51831       };
51832     }
51833   }
51834
51835   jresult = (void *)result;
51836   return jresult;
51837 }
51838
51839
51840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51841   void * jresult ;
51842   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51843   Dali::Vector< float >::Iterator result;
51844
51845   arg1 = (Dali::Vector< float > *)jarg1;
51846   {
51847     try {
51848       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51849     } catch (std::out_of_range& e) {
51850       {
51851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51852       };
51853     } catch (std::exception& e) {
51854       {
51855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51856       };
51857     } catch (Dali::DaliException e) {
51858       {
51859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51860       };
51861     } catch (...) {
51862       {
51863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51864       };
51865     }
51866   }
51867
51868   jresult = (void *)result;
51869   return jresult;
51870 }
51871
51872
51873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51874   void * jresult ;
51875   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51876   Dali::Vector< float >::SizeType arg2 ;
51877   Dali::Vector< float >::ItemType *result = 0 ;
51878
51879   arg1 = (Dali::Vector< float > *)jarg1;
51880   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51881   {
51882     try {
51883       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51884     } catch (std::out_of_range& e) {
51885       {
51886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51887       };
51888     } catch (std::exception& e) {
51889       {
51890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51891       };
51892     } catch (Dali::DaliException e) {
51893       {
51894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51895       };
51896     } catch (...) {
51897       {
51898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51899       };
51900     }
51901   }
51902
51903   jresult = (void *)result;
51904   return jresult;
51905 }
51906
51907
51908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51909   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51910   Dali::Vector< float >::ItemType *arg2 = 0 ;
51911   Dali::Vector< float >::ItemType temp2 ;
51912
51913   arg1 = (Dali::Vector< float > *)jarg1;
51914   temp2 = (Dali::Vector< float >::ItemType)jarg2;
51915   arg2 = &temp2;
51916   {
51917     try {
51918       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
51919     } catch (std::out_of_range& e) {
51920       {
51921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51922       };
51923     } catch (std::exception& e) {
51924       {
51925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51926       };
51927     } catch (Dali::DaliException e) {
51928       {
51929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51930       };
51931     } catch (...) {
51932       {
51933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51934       };
51935     }
51936   }
51937
51938 }
51939
51940
51941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
51942   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51943   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51944   Dali::Vector< float >::ItemType *arg3 = 0 ;
51945   Dali::Vector< float >::ItemType temp3 ;
51946
51947   arg1 = (Dali::Vector< float > *)jarg1;
51948   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51949   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51950   arg3 = &temp3;
51951   {
51952     try {
51953       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51954     } catch (std::out_of_range& e) {
51955       {
51956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51957       };
51958     } catch (std::exception& e) {
51959       {
51960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51961       };
51962     } catch (Dali::DaliException e) {
51963       {
51964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51965       };
51966     } catch (...) {
51967       {
51968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51969       };
51970     }
51971   }
51972
51973 }
51974
51975
51976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51977   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51978   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51979   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
51980   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
51981
51982   arg1 = (Dali::Vector< float > *)jarg1;
51983   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51984   arg3 = (Dali::Vector< float >::Iterator)jarg3;
51985   arg4 = (Dali::Vector< float >::Iterator)jarg4;
51986   {
51987     try {
51988       (arg1)->Insert(arg2,arg3,arg4);
51989     } catch (std::out_of_range& e) {
51990       {
51991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51992       };
51993     } catch (std::exception& e) {
51994       {
51995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51996       };
51997     } catch (Dali::DaliException e) {
51998       {
51999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52000       };
52001     } catch (...) {
52002       {
52003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52004       };
52005     }
52006   }
52007
52008 }
52009
52010
52011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52012   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52013   Dali::Vector< float >::SizeType arg2 ;
52014
52015   arg1 = (Dali::Vector< float > *)jarg1;
52016   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52017   {
52018     try {
52019       (arg1)->Reserve(arg2);
52020     } catch (std::out_of_range& e) {
52021       {
52022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52023       };
52024     } catch (std::exception& e) {
52025       {
52026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52027       };
52028     } catch (Dali::DaliException e) {
52029       {
52030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52031       };
52032     } catch (...) {
52033       {
52034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52035       };
52036     }
52037   }
52038
52039 }
52040
52041 //// ========================= end of part 2 =============================
52042
52043 //// ========================== start part 3 ===============================
52044
52045
52046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52047   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52048   Dali::Vector< float >::SizeType arg2 ;
52049
52050   arg1 = (Dali::Vector< float > *)jarg1;
52051   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52052   {
52053     try {
52054       (arg1)->Resize(arg2);
52055     } catch (std::out_of_range& e) {
52056       {
52057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52058       };
52059     } catch (std::exception& e) {
52060       {
52061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52062       };
52063     } catch (Dali::DaliException e) {
52064       {
52065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52066       };
52067     } catch (...) {
52068       {
52069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52070       };
52071     }
52072   }
52073
52074 }
52075
52076
52077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52078   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52079   Dali::Vector< float >::SizeType arg2 ;
52080   Dali::Vector< float >::ItemType *arg3 = 0 ;
52081   Dali::Vector< float >::ItemType temp3 ;
52082
52083   arg1 = (Dali::Vector< float > *)jarg1;
52084   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52085   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52086   arg3 = &temp3;
52087   {
52088     try {
52089       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52090     } catch (std::out_of_range& e) {
52091       {
52092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52093       };
52094     } catch (std::exception& e) {
52095       {
52096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52097       };
52098     } catch (Dali::DaliException e) {
52099       {
52100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52101       };
52102     } catch (...) {
52103       {
52104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52105       };
52106     }
52107   }
52108
52109 }
52110
52111
52112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52113   void * jresult ;
52114   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52115   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52116   Dali::Vector< float >::Iterator result;
52117
52118   arg1 = (Dali::Vector< float > *)jarg1;
52119   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52120   {
52121     try {
52122       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52123     } catch (std::out_of_range& e) {
52124       {
52125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52126       };
52127     } catch (std::exception& e) {
52128       {
52129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52130       };
52131     } catch (Dali::DaliException e) {
52132       {
52133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52134       };
52135     } catch (...) {
52136       {
52137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52138       };
52139     }
52140   }
52141
52142   jresult = (void *)result;
52143   return jresult;
52144 }
52145
52146
52147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52148   void * jresult ;
52149   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52150   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52151   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52152   Dali::Vector< float >::Iterator result;
52153
52154   arg1 = (Dali::Vector< float > *)jarg1;
52155   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52156   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52157   {
52158     try {
52159       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
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_Remove(void * jarg1, void * jarg2) {
52185   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52186   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52187
52188   arg1 = (Dali::Vector< float > *)jarg1;
52189   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52190   {
52191     try {
52192       (arg1)->Remove(arg2);
52193     } catch (std::out_of_range& e) {
52194       {
52195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52196       };
52197     } catch (std::exception& e) {
52198       {
52199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52200       };
52201     } catch (Dali::DaliException e) {
52202       {
52203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52204       };
52205     } catch (...) {
52206       {
52207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52208       };
52209     }
52210   }
52211
52212 }
52213
52214
52215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52216   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52217   Dali::Vector< float > *arg2 = 0 ;
52218
52219   arg1 = (Dali::Vector< float > *)jarg1;
52220   arg2 = (Dali::Vector< float > *)jarg2;
52221   if (!arg2) {
52222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52223     return ;
52224   }
52225   {
52226     try {
52227       (arg1)->Swap(*arg2);
52228     } catch (std::out_of_range& e) {
52229       {
52230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52231       };
52232     } catch (std::exception& e) {
52233       {
52234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52235       };
52236     } catch (Dali::DaliException e) {
52237       {
52238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52239       };
52240     } catch (...) {
52241       {
52242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52243       };
52244     }
52245   }
52246
52247 }
52248
52249
52250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52251   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52252
52253   arg1 = (Dali::Vector< float > *)jarg1;
52254   {
52255     try {
52256       (arg1)->Clear();
52257     } catch (std::out_of_range& e) {
52258       {
52259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52260       };
52261     } catch (std::exception& e) {
52262       {
52263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52264       };
52265     } catch (Dali::DaliException e) {
52266       {
52267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52268       };
52269     } catch (...) {
52270       {
52271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52272       };
52273     }
52274   }
52275
52276 }
52277
52278
52279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52280   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52281
52282   arg1 = (Dali::Vector< float > *)jarg1;
52283   {
52284     try {
52285       (arg1)->Release();
52286     } catch (std::out_of_range& e) {
52287       {
52288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52289       };
52290     } catch (std::exception& e) {
52291       {
52292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52293       };
52294     } catch (Dali::DaliException e) {
52295       {
52296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52297       };
52298     } catch (...) {
52299       {
52300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52301       };
52302     }
52303   }
52304
52305 }
52306
52307
52308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52309   int jresult ;
52310   int result;
52311
52312   result = (int)Dali::Vector< unsigned char >::BaseType;
52313   jresult = (int)result;
52314   return jresult;
52315 }
52316
52317
52318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52319   void * jresult ;
52320   Dali::Vector< unsigned char > *result = 0 ;
52321
52322   {
52323     try {
52324       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52325     } catch (std::out_of_range& e) {
52326       {
52327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52328       };
52329     } catch (std::exception& e) {
52330       {
52331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52332       };
52333     } catch (Dali::DaliException e) {
52334       {
52335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52336       };
52337     } catch (...) {
52338       {
52339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52340       };
52341     }
52342   }
52343
52344   jresult = (void *)result;
52345   return jresult;
52346 }
52347
52348
52349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52350   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52351
52352   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52353   {
52354     try {
52355       delete arg1;
52356     } catch (std::out_of_range& e) {
52357       {
52358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52359       };
52360     } catch (std::exception& e) {
52361       {
52362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52363       };
52364     } catch (Dali::DaliException e) {
52365       {
52366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52367       };
52368     } catch (...) {
52369       {
52370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52371       };
52372     }
52373   }
52374
52375 }
52376
52377
52378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52379   void * jresult ;
52380   Dali::Vector< unsigned char > *arg1 = 0 ;
52381   Dali::Vector< unsigned char > *result = 0 ;
52382
52383   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52384   if (!arg1) {
52385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52386     return 0;
52387   }
52388   {
52389     try {
52390       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52391     } catch (std::out_of_range& e) {
52392       {
52393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52394       };
52395     } catch (std::exception& e) {
52396       {
52397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52398       };
52399     } catch (Dali::DaliException e) {
52400       {
52401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52402       };
52403     } catch (...) {
52404       {
52405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52406       };
52407     }
52408   }
52409
52410   jresult = (void *)result;
52411   return jresult;
52412 }
52413
52414
52415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52416   void * jresult ;
52417   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52418   Dali::Vector< unsigned char > *arg2 = 0 ;
52419   Dali::Vector< unsigned char > *result = 0 ;
52420
52421   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52422   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52423   if (!arg2) {
52424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52425     return 0;
52426   }
52427   {
52428     try {
52429       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52430     } catch (std::out_of_range& e) {
52431       {
52432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52433       };
52434     } catch (std::exception& e) {
52435       {
52436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52437       };
52438     } catch (Dali::DaliException e) {
52439       {
52440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52441       };
52442     } catch (...) {
52443       {
52444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52445       };
52446     }
52447   }
52448
52449   jresult = (void *)result;
52450   return jresult;
52451 }
52452
52453
52454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52455   void * jresult ;
52456   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52457   Dali::Vector< unsigned char >::Iterator result;
52458
52459   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52460   {
52461     try {
52462       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52463     } catch (std::out_of_range& e) {
52464       {
52465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52466       };
52467     } catch (std::exception& e) {
52468       {
52469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52470       };
52471     } catch (Dali::DaliException e) {
52472       {
52473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52474       };
52475     } catch (...) {
52476       {
52477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52478       };
52479     }
52480   }
52481
52482   jresult = (void *)result;
52483   return jresult;
52484 }
52485
52486
52487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52488   void * jresult ;
52489   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52490   Dali::Vector< unsigned char >::Iterator result;
52491
52492   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52493   {
52494     try {
52495       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52496     } catch (std::out_of_range& e) {
52497       {
52498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52499       };
52500     } catch (std::exception& e) {
52501       {
52502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52503       };
52504     } catch (Dali::DaliException e) {
52505       {
52506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52507       };
52508     } catch (...) {
52509       {
52510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52511       };
52512     }
52513   }
52514
52515   jresult = (void *)result;
52516   return jresult;
52517 }
52518
52519
52520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52521   void * jresult ;
52522   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52523   Dali::Vector< unsigned char >::SizeType arg2 ;
52524   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52525
52526   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52527   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52528   {
52529     try {
52530       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52531     } catch (std::out_of_range& e) {
52532       {
52533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52534       };
52535     } catch (std::exception& e) {
52536       {
52537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52538       };
52539     } catch (Dali::DaliException e) {
52540       {
52541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52542       };
52543     } catch (...) {
52544       {
52545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52546       };
52547     }
52548   }
52549
52550   jresult = (void *)result;
52551   return jresult;
52552 }
52553
52554
52555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52556   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52557   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52558   Dali::Vector< unsigned char >::ItemType temp2 ;
52559
52560   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52561   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52562   arg2 = &temp2;
52563   {
52564     try {
52565       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52566     } catch (std::out_of_range& e) {
52567       {
52568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52569       };
52570     } catch (std::exception& e) {
52571       {
52572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52573       };
52574     } catch (Dali::DaliException e) {
52575       {
52576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52577       };
52578     } catch (...) {
52579       {
52580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52581       };
52582     }
52583   }
52584
52585 }
52586
52587
52588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52589   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52590   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52591   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52592   Dali::Vector< unsigned char >::ItemType temp3 ;
52593
52594   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52595   arg2 = jarg2;
52596   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52597   arg3 = &temp3;
52598   {
52599     try {
52600       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52601     } catch (std::out_of_range& e) {
52602       {
52603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52604       };
52605     } catch (std::exception& e) {
52606       {
52607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52608       };
52609     } catch (Dali::DaliException e) {
52610       {
52611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52612       };
52613     } catch (...) {
52614       {
52615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52616       };
52617     }
52618   }
52619
52620
52621
52622 }
52623
52624
52625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
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 >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52629   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52630
52631   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52632   arg2 = jarg2;
52633   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52634   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52635   {
52636     try {
52637       (arg1)->Insert(arg2,arg3,arg4);
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_Reserve(void * jarg1, unsigned long jarg2) {
52663   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52664   Dali::Vector< unsigned char >::SizeType arg2 ;
52665
52666   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52667   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52668   {
52669     try {
52670       (arg1)->Reserve(arg2);
52671     } catch (std::out_of_range& e) {
52672       {
52673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52674       };
52675     } catch (std::exception& e) {
52676       {
52677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52678       };
52679     } catch (Dali::DaliException e) {
52680       {
52681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52682       };
52683     } catch (...) {
52684       {
52685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52686       };
52687     }
52688   }
52689
52690 }
52691
52692
52693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52694   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52695   Dali::Vector< unsigned char >::SizeType arg2 ;
52696
52697   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52698   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52699   {
52700     try {
52701       (arg1)->Resize(arg2);
52702     } catch (std::out_of_range& e) {
52703       {
52704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52705       };
52706     } catch (std::exception& e) {
52707       {
52708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52709       };
52710     } catch (Dali::DaliException e) {
52711       {
52712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52713       };
52714     } catch (...) {
52715       {
52716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52717       };
52718     }
52719   }
52720
52721 }
52722
52723
52724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52725   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52726   Dali::Vector< unsigned char >::SizeType arg2 ;
52727   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52728   Dali::Vector< unsigned char >::ItemType temp3 ;
52729
52730   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52731   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52732   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52733   arg3 = &temp3;
52734   {
52735     try {
52736       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52737     } catch (std::out_of_range& e) {
52738       {
52739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52740       };
52741     } catch (std::exception& e) {
52742       {
52743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52744       };
52745     } catch (Dali::DaliException e) {
52746       {
52747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52748       };
52749     } catch (...) {
52750       {
52751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52752       };
52753     }
52754   }
52755
52756 }
52757
52758
52759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52760   void * jresult ;
52761   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52762   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52763   Dali::Vector< unsigned char >::Iterator result;
52764
52765   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52766   arg2 = jarg2;
52767   {
52768     try {
52769       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52770     } catch (std::out_of_range& e) {
52771       {
52772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52773       };
52774     } catch (std::exception& e) {
52775       {
52776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52777       };
52778     } catch (Dali::DaliException e) {
52779       {
52780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52781       };
52782     } catch (...) {
52783       {
52784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52785       };
52786     }
52787   }
52788
52789   jresult = (void *)result;
52790
52791
52792   return jresult;
52793 }
52794
52795
52796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
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 arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52801   Dali::Vector< unsigned char >::Iterator result;
52802
52803   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52804   arg2 = jarg2;
52805   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52806   {
52807     try {
52808       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52809     } catch (std::out_of_range& e) {
52810       {
52811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52812       };
52813     } catch (std::exception& e) {
52814       {
52815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52816       };
52817     } catch (Dali::DaliException e) {
52818       {
52819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52820       };
52821     } catch (...) {
52822       {
52823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52824       };
52825     }
52826   }
52827
52828   jresult = (void *)result;
52829
52830
52831   return jresult;
52832 }
52833
52834
52835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52836   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52837   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52838
52839   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52840   arg2 = jarg2;
52841   {
52842     try {
52843       (arg1)->Remove(arg2);
52844     } catch (std::out_of_range& e) {
52845       {
52846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52847       };
52848     } catch (std::exception& e) {
52849       {
52850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52851       };
52852     } catch (Dali::DaliException e) {
52853       {
52854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52855       };
52856     } catch (...) {
52857       {
52858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52859       };
52860     }
52861   }
52862
52863
52864
52865 }
52866
52867
52868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52869   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52870   Dali::Vector< unsigned char > *arg2 = 0 ;
52871
52872   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52873   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52874   if (!arg2) {
52875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52876     return ;
52877   }
52878   {
52879     try {
52880       (arg1)->Swap(*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 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52904   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52905
52906   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52907   {
52908     try {
52909       (arg1)->Clear();
52910     } catch (std::out_of_range& e) {
52911       {
52912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52913       };
52914     } catch (std::exception& e) {
52915       {
52916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52917       };
52918     } catch (Dali::DaliException e) {
52919       {
52920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52921       };
52922     } catch (...) {
52923       {
52924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52925       };
52926     }
52927   }
52928
52929 }
52930
52931
52932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
52933   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52934
52935   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52936   {
52937     try {
52938       (arg1)->Release();
52939     } catch (std::out_of_range& e) {
52940       {
52941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52942       };
52943     } catch (std::exception& e) {
52944       {
52945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52946       };
52947     } catch (Dali::DaliException e) {
52948       {
52949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52950       };
52951     } catch (...) {
52952       {
52953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52954       };
52955     }
52956   }
52957
52958 }
52959
52960
52961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
52962   int jresult ;
52963   int result;
52964
52965   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
52966   jresult = (int)result;
52967   return jresult;
52968 }
52969
52970
52971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
52972   void * jresult ;
52973   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52974
52975   {
52976     try {
52977       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
52978     } catch (std::out_of_range& e) {
52979       {
52980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52981       };
52982     } catch (std::exception& e) {
52983       {
52984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52985       };
52986     } catch (Dali::DaliException e) {
52987       {
52988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52989       };
52990     } catch (...) {
52991       {
52992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52993       };
52994     }
52995   }
52996
52997   jresult = (void *)result;
52998   return jresult;
52999 }
53000
53001
53002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53003   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53004
53005   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53006   {
53007     try {
53008       delete arg1;
53009     } catch (std::out_of_range& e) {
53010       {
53011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53012       };
53013     } catch (std::exception& e) {
53014       {
53015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53016       };
53017     } catch (Dali::DaliException e) {
53018       {
53019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53020       };
53021     } catch (...) {
53022       {
53023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53024       };
53025     }
53026   }
53027
53028 }
53029
53030
53031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53032   void * jresult ;
53033   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53034   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53035
53036   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53037   if (!arg1) {
53038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53039     return 0;
53040   }
53041   {
53042     try {
53043       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53044     } catch (std::out_of_range& e) {
53045       {
53046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53047       };
53048     } catch (std::exception& e) {
53049       {
53050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53051       };
53052     } catch (Dali::DaliException e) {
53053       {
53054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53055       };
53056     } catch (...) {
53057       {
53058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53059       };
53060     }
53061   }
53062
53063   jresult = (void *)result;
53064   return jresult;
53065 }
53066
53067
53068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53069   void * jresult ;
53070   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53071   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53072   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53073
53074   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53075   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53076   if (!arg2) {
53077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53078     return 0;
53079   }
53080   {
53081     try {
53082       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53083     } catch (std::out_of_range& e) {
53084       {
53085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53086       };
53087     } catch (std::exception& e) {
53088       {
53089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53090       };
53091     } catch (Dali::DaliException e) {
53092       {
53093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53094       };
53095     } catch (...) {
53096       {
53097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53098       };
53099     }
53100   }
53101
53102   jresult = (void *)result;
53103   return jresult;
53104 }
53105
53106
53107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53108   void * jresult ;
53109   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53110   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53111
53112   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53113   {
53114     try {
53115       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53116     } catch (std::out_of_range& e) {
53117       {
53118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53119       };
53120     } catch (std::exception& e) {
53121       {
53122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53123       };
53124     } catch (Dali::DaliException e) {
53125       {
53126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53127       };
53128     } catch (...) {
53129       {
53130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53131       };
53132     }
53133   }
53134
53135   jresult = (void *)result;
53136   return jresult;
53137 }
53138
53139
53140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53141   void * jresult ;
53142   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53143   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53144
53145   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53146   {
53147     try {
53148       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53149     } catch (std::out_of_range& e) {
53150       {
53151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53152       };
53153     } catch (std::exception& e) {
53154       {
53155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53156       };
53157     } catch (Dali::DaliException e) {
53158       {
53159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53160       };
53161     } catch (...) {
53162       {
53163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53164       };
53165     }
53166   }
53167
53168   jresult = (void *)result;
53169   return jresult;
53170 }
53171
53172
53173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53174   void * jresult ;
53175   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53176   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53177   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53178
53179   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53180   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53181   {
53182     try {
53183       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53184     } catch (std::out_of_range& e) {
53185       {
53186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53187       };
53188     } catch (std::exception& e) {
53189       {
53190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53191       };
53192     } catch (Dali::DaliException e) {
53193       {
53194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53195       };
53196     } catch (...) {
53197       {
53198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53199       };
53200     }
53201   }
53202
53203   jresult = (void *)result;
53204   return jresult;
53205 }
53206
53207
53208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53209   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53210   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53211
53212   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53213   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53214   if (!arg2) {
53215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53216     return ;
53217   }
53218   {
53219     try {
53220       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53221     } catch (std::out_of_range& e) {
53222       {
53223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53224       };
53225     } catch (std::exception& e) {
53226       {
53227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53228       };
53229     } catch (Dali::DaliException e) {
53230       {
53231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53232       };
53233     } catch (...) {
53234       {
53235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53236       };
53237     }
53238   }
53239
53240 }
53241
53242
53243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53244   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53245   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53246   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53247
53248   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53249   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53250   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53251   if (!arg3) {
53252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53253     return ;
53254   }
53255   {
53256     try {
53257       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
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_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
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 >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53284   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53285
53286   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53287   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53288   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53289   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53290   {
53291     try {
53292       (arg1)->Insert(arg2,arg3,arg4);
53293     } catch (std::out_of_range& e) {
53294       {
53295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53296       };
53297     } catch (std::exception& e) {
53298       {
53299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53300       };
53301     } catch (Dali::DaliException e) {
53302       {
53303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53304       };
53305     } catch (...) {
53306       {
53307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53308       };
53309     }
53310   }
53311
53312 }
53313
53314
53315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53316   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53317   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53318
53319   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53320   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53321   {
53322     try {
53323       (arg1)->Reserve(arg2);
53324     } catch (std::out_of_range& e) {
53325       {
53326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53327       };
53328     } catch (std::exception& e) {
53329       {
53330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53331       };
53332     } catch (Dali::DaliException e) {
53333       {
53334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53335       };
53336     } catch (...) {
53337       {
53338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53339       };
53340     }
53341   }
53342
53343 }
53344
53345
53346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53347   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53348   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53349
53350   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53351   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53352   {
53353     try {
53354       (arg1)->Resize(arg2);
53355     } catch (std::out_of_range& e) {
53356       {
53357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53358       };
53359     } catch (std::exception& e) {
53360       {
53361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53362       };
53363     } catch (Dali::DaliException e) {
53364       {
53365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53366       };
53367     } catch (...) {
53368       {
53369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53370       };
53371     }
53372   }
53373
53374 }
53375
53376
53377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53378   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53379   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53380   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53381
53382   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53383   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53384   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53385   if (!arg3) {
53386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53387     return ;
53388   }
53389   {
53390     try {
53391       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
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_Erase__SWIG_0(void * jarg1, void * jarg2) {
53415   void * jresult ;
53416   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53417   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53418   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53419
53420   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53421   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53422   {
53423     try {
53424       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53425     } catch (std::out_of_range& e) {
53426       {
53427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53428       };
53429     } catch (std::exception& e) {
53430       {
53431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53432       };
53433     } catch (Dali::DaliException e) {
53434       {
53435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53436       };
53437     } catch (...) {
53438       {
53439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53440       };
53441     }
53442   }
53443
53444   jresult = (void *)result;
53445   return jresult;
53446 }
53447
53448
53449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53450   void * jresult ;
53451   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53452   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53453   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53454   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53455
53456   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53457   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53458   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53459   {
53460     try {
53461       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
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_Remove(void * jarg1, void * jarg2) {
53487   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53488   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53489
53490   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53491   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53492   {
53493     try {
53494       (arg1)->Remove(arg2);
53495     } catch (std::out_of_range& e) {
53496       {
53497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53498       };
53499     } catch (std::exception& e) {
53500       {
53501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53502       };
53503     } catch (Dali::DaliException e) {
53504       {
53505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53506       };
53507     } catch (...) {
53508       {
53509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53510       };
53511     }
53512   }
53513
53514 }
53515
53516
53517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53518   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53519   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53520
53521   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53522   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53523   if (!arg2) {
53524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53525     return ;
53526   }
53527   {
53528     try {
53529       (arg1)->Swap(*arg2);
53530     } catch (std::out_of_range& e) {
53531       {
53532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53533       };
53534     } catch (std::exception& e) {
53535       {
53536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53537       };
53538     } catch (Dali::DaliException e) {
53539       {
53540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53541       };
53542     } catch (...) {
53543       {
53544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53545       };
53546     }
53547   }
53548
53549 }
53550
53551
53552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53553   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53554
53555   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53556   {
53557     try {
53558       (arg1)->Clear();
53559     } catch (std::out_of_range& e) {
53560       {
53561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53562       };
53563     } catch (std::exception& e) {
53564       {
53565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53566       };
53567     } catch (Dali::DaliException e) {
53568       {
53569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53570       };
53571     } catch (...) {
53572       {
53573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53574       };
53575     }
53576   }
53577
53578 }
53579
53580
53581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53582   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53583
53584   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53585   {
53586     try {
53587       (arg1)->Release();
53588     } catch (std::out_of_range& e) {
53589       {
53590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53591       };
53592     } catch (std::exception& e) {
53593       {
53594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53595       };
53596     } catch (Dali::DaliException e) {
53597       {
53598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53599       };
53600     } catch (...) {
53601       {
53602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53603       };
53604     }
53605   }
53606
53607 }
53608
53609
53610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53611   void * jresult ;
53612   Dali::Signal< void () > *result = 0 ;
53613
53614   {
53615     try {
53616       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53617     } catch (std::out_of_range& e) {
53618       {
53619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53620       };
53621     } catch (std::exception& e) {
53622       {
53623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53624       };
53625     } catch (Dali::DaliException e) {
53626       {
53627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53628       };
53629     } catch (...) {
53630       {
53631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53632       };
53633     }
53634   }
53635
53636   jresult = (void *)result;
53637   return jresult;
53638 }
53639
53640
53641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53642   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53643
53644   arg1 = (Dali::Signal< void () > *)jarg1;
53645   {
53646     try {
53647       delete arg1;
53648     } catch (std::out_of_range& e) {
53649       {
53650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53651       };
53652     } catch (std::exception& e) {
53653       {
53654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53655       };
53656     } catch (Dali::DaliException e) {
53657       {
53658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53659       };
53660     } catch (...) {
53661       {
53662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53663       };
53664     }
53665   }
53666
53667 }
53668
53669
53670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53671   unsigned int jresult ;
53672   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53673   bool result;
53674
53675   arg1 = (Dali::Signal< void () > *)jarg1;
53676   {
53677     try {
53678       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53679     } catch (std::out_of_range& e) {
53680       {
53681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53682       };
53683     } catch (std::exception& e) {
53684       {
53685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53686       };
53687     } catch (Dali::DaliException e) {
53688       {
53689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53690       };
53691     } catch (...) {
53692       {
53693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53694       };
53695     }
53696   }
53697
53698   jresult = result;
53699   return jresult;
53700 }
53701
53702
53703 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53704   unsigned long jresult ;
53705   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53706   std::size_t result;
53707
53708   arg1 = (Dali::Signal< void () > *)jarg1;
53709   {
53710     try {
53711       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53712     } catch (std::out_of_range& e) {
53713       {
53714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53715       };
53716     } catch (std::exception& e) {
53717       {
53718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53719       };
53720     } catch (Dali::DaliException e) {
53721       {
53722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53723       };
53724     } catch (...) {
53725       {
53726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53727       };
53728     }
53729   }
53730
53731   jresult = (unsigned long)result;
53732   return jresult;
53733 }
53734
53735
53736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53737   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53738   void (*arg2)() = (void (*)()) 0 ;
53739
53740   arg1 = (Dali::Signal< void () > *)jarg1;
53741   arg2 = (void (*)())jarg2;
53742   {
53743     try {
53744       (arg1)->Connect(arg2);
53745     } catch (std::out_of_range& e) {
53746       {
53747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53748       };
53749     } catch (std::exception& e) {
53750       {
53751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53752       };
53753     } catch (Dali::DaliException e) {
53754       {
53755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53756       };
53757     } catch (...) {
53758       {
53759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53760       };
53761     }
53762   }
53763
53764 }
53765
53766
53767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53768   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53769   void (*arg2)() = (void (*)()) 0 ;
53770
53771   arg1 = (Dali::Signal< void () > *)jarg1;
53772   arg2 = (void (*)())jarg2;
53773   {
53774     try {
53775       (arg1)->Disconnect(arg2);
53776     } catch (std::out_of_range& e) {
53777       {
53778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53779       };
53780     } catch (std::exception& e) {
53781       {
53782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53783       };
53784     } catch (Dali::DaliException e) {
53785       {
53786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53787       };
53788     } catch (...) {
53789       {
53790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53791       };
53792     }
53793   }
53794
53795 }
53796
53797
53798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53799   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53800   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53801   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53802
53803   arg1 = (Dali::Signal< void () > *)jarg1;
53804   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53805   arg3 = (Dali::FunctorDelegate *)jarg3;
53806   {
53807     try {
53808       (arg1)->Connect(arg2,arg3);
53809     } catch (std::out_of_range& e) {
53810       {
53811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53812       };
53813     } catch (std::exception& e) {
53814       {
53815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53816       };
53817     } catch (Dali::DaliException e) {
53818       {
53819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53820       };
53821     } catch (...) {
53822       {
53823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53824       };
53825     }
53826   }
53827
53828 }
53829
53830
53831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53832   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53833
53834   arg1 = (Dali::Signal< void () > *)jarg1;
53835   {
53836     try {
53837       (arg1)->Emit();
53838     } catch (std::out_of_range& e) {
53839       {
53840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53841       };
53842     } catch (std::exception& e) {
53843       {
53844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53845       };
53846     } catch (Dali::DaliException e) {
53847       {
53848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53849       };
53850     } catch (...) {
53851       {
53852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53853       };
53854     }
53855   }
53856
53857 }
53858
53859
53860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53861   unsigned int jresult ;
53862   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53863   bool result;
53864
53865   arg1 = (Dali::Signal< void (float) > *)jarg1;
53866   {
53867     try {
53868       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53869     } catch (std::out_of_range& e) {
53870       {
53871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53872       };
53873     } catch (std::exception& e) {
53874       {
53875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53876       };
53877     } catch (Dali::DaliException e) {
53878       {
53879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53880       };
53881     } catch (...) {
53882       {
53883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53884       };
53885     }
53886   }
53887
53888   jresult = result;
53889   return jresult;
53890 }
53891
53892
53893 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53894   unsigned long jresult ;
53895   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53896   std::size_t result;
53897
53898   arg1 = (Dali::Signal< void (float) > *)jarg1;
53899   {
53900     try {
53901       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53902     } catch (std::out_of_range& e) {
53903       {
53904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53905       };
53906     } catch (std::exception& e) {
53907       {
53908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53909       };
53910     } catch (Dali::DaliException e) {
53911       {
53912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53913       };
53914     } catch (...) {
53915       {
53916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53917       };
53918     }
53919   }
53920
53921   jresult = (unsigned long)result;
53922   return jresult;
53923 }
53924
53925
53926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
53927   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53928   void (*arg2)(float) = (void (*)(float)) 0 ;
53929
53930   arg1 = (Dali::Signal< void (float) > *)jarg1;
53931   arg2 = (void (*)(float))jarg2;
53932   {
53933     try {
53934       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
53935     } catch (std::out_of_range& e) {
53936       {
53937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53938       };
53939     } catch (std::exception& e) {
53940       {
53941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53942       };
53943     } catch (Dali::DaliException e) {
53944       {
53945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53946       };
53947     } catch (...) {
53948       {
53949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53950       };
53951     }
53952   }
53953
53954 }
53955
53956
53957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
53958   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53959   void (*arg2)(float) = (void (*)(float)) 0 ;
53960
53961   arg1 = (Dali::Signal< void (float) > *)jarg1;
53962   arg2 = (void (*)(float))jarg2;
53963   {
53964     try {
53965       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
53966     } catch (std::out_of_range& e) {
53967       {
53968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53969       };
53970     } catch (std::exception& e) {
53971       {
53972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53973       };
53974     } catch (Dali::DaliException e) {
53975       {
53976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53977       };
53978     } catch (...) {
53979       {
53980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53981       };
53982     }
53983   }
53984
53985 }
53986
53987
53988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
53989   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53990   float arg2 ;
53991
53992   arg1 = (Dali::Signal< void (float) > *)jarg1;
53993   arg2 = (float)jarg2;
53994   {
53995     try {
53996       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
53997     } catch (std::out_of_range& e) {
53998       {
53999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54000       };
54001     } catch (std::exception& e) {
54002       {
54003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54004       };
54005     } catch (Dali::DaliException e) {
54006       {
54007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54008       };
54009     } catch (...) {
54010       {
54011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54012       };
54013     }
54014   }
54015
54016 }
54017
54018
54019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54020   void * jresult ;
54021   Dali::Signal< void (float) > *result = 0 ;
54022
54023   {
54024     try {
54025       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54026     } catch (std::out_of_range& e) {
54027       {
54028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54029       };
54030     } catch (std::exception& e) {
54031       {
54032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54033       };
54034     } catch (Dali::DaliException e) {
54035       {
54036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54037       };
54038     } catch (...) {
54039       {
54040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54041       };
54042     }
54043   }
54044
54045   jresult = (void *)result;
54046   return jresult;
54047 }
54048
54049
54050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54051   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54052
54053   arg1 = (Dali::Signal< void (float) > *)jarg1;
54054   {
54055     try {
54056       delete arg1;
54057     } catch (std::out_of_range& e) {
54058       {
54059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54060       };
54061     } catch (std::exception& e) {
54062       {
54063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54064       };
54065     } catch (Dali::DaliException e) {
54066       {
54067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54068       };
54069     } catch (...) {
54070       {
54071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54072       };
54073     }
54074   }
54075
54076 }
54077
54078
54079 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54080   unsigned int jresult ;
54081   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54082   bool result;
54083
54084   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54085   {
54086     try {
54087       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54088     } catch (std::out_of_range& e) {
54089       {
54090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54091       };
54092     } catch (std::exception& e) {
54093       {
54094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54095       };
54096     } catch (Dali::DaliException e) {
54097       {
54098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54099       };
54100     } catch (...) {
54101       {
54102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54103       };
54104     }
54105   }
54106
54107   jresult = result;
54108   return jresult;
54109 }
54110
54111
54112 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54113   unsigned long jresult ;
54114   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54115   std::size_t result;
54116
54117   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54118   {
54119     try {
54120       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54121     } catch (std::out_of_range& e) {
54122       {
54123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54124       };
54125     } catch (std::exception& e) {
54126       {
54127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54128       };
54129     } catch (Dali::DaliException e) {
54130       {
54131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54132       };
54133     } catch (...) {
54134       {
54135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54136       };
54137     }
54138   }
54139
54140   jresult = (unsigned long)result;
54141   return jresult;
54142 }
54143
54144
54145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54146   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54147   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54148
54149   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54150   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54151   {
54152     try {
54153       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54154     } catch (std::out_of_range& e) {
54155       {
54156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54157       };
54158     } catch (std::exception& e) {
54159       {
54160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54161       };
54162     } catch (Dali::DaliException e) {
54163       {
54164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54165       };
54166     } catch (...) {
54167       {
54168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54169       };
54170     }
54171   }
54172
54173 }
54174
54175
54176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54177   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54178   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54179
54180   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54181   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54182   {
54183     try {
54184       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54185     } catch (std::out_of_range& e) {
54186       {
54187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54188       };
54189     } catch (std::exception& e) {
54190       {
54191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54192       };
54193     } catch (Dali::DaliException e) {
54194       {
54195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54196       };
54197     } catch (...) {
54198       {
54199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54200       };
54201     }
54202   }
54203
54204 }
54205
54206
54207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54208   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54209   Dali::BaseHandle arg2 ;
54210   Dali::BaseHandle *argp2 ;
54211
54212   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54213   argp2 = (Dali::BaseHandle *)jarg2;
54214   if (!argp2) {
54215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54216     return ;
54217   }
54218   arg2 = *argp2;
54219   {
54220     try {
54221       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(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_new_ObjectCreatedSignal() {
54245   void * jresult ;
54246   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54247
54248   {
54249     try {
54250       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54251     } catch (std::out_of_range& e) {
54252       {
54253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54254       };
54255     } catch (std::exception& e) {
54256       {
54257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54258       };
54259     } catch (Dali::DaliException e) {
54260       {
54261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54262       };
54263     } catch (...) {
54264       {
54265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54266       };
54267     }
54268   }
54269
54270   jresult = (void *)result;
54271   return jresult;
54272 }
54273
54274
54275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54276   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54277
54278   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54279   {
54280     try {
54281       delete arg1;
54282     } catch (std::out_of_range& e) {
54283       {
54284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54285       };
54286     } catch (std::exception& e) {
54287       {
54288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54289       };
54290     } catch (Dali::DaliException e) {
54291       {
54292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54293       };
54294     } catch (...) {
54295       {
54296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54297       };
54298     }
54299   }
54300
54301 }
54302
54303
54304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54305   unsigned int jresult ;
54306   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54307   bool result;
54308
54309   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54310   {
54311     try {
54312       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54313     } catch (std::out_of_range& e) {
54314       {
54315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54316       };
54317     } catch (std::exception& e) {
54318       {
54319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54320       };
54321     } catch (Dali::DaliException e) {
54322       {
54323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54324       };
54325     } catch (...) {
54326       {
54327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54328       };
54329     }
54330   }
54331
54332   jresult = result;
54333   return jresult;
54334 }
54335
54336
54337 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54338   unsigned long jresult ;
54339   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54340   std::size_t result;
54341
54342   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54343   {
54344     try {
54345       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54346     } catch (std::out_of_range& e) {
54347       {
54348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54349       };
54350     } catch (std::exception& e) {
54351       {
54352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54353       };
54354     } catch (Dali::DaliException e) {
54355       {
54356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54357       };
54358     } catch (...) {
54359       {
54360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54361       };
54362     }
54363   }
54364
54365   jresult = (unsigned long)result;
54366   return jresult;
54367 }
54368
54369
54370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54371   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54372   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54373
54374   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54375   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54376   {
54377     try {
54378       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54379     } catch (std::out_of_range& e) {
54380       {
54381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54382       };
54383     } catch (std::exception& e) {
54384       {
54385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54386       };
54387     } catch (Dali::DaliException e) {
54388       {
54389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54390       };
54391     } catch (...) {
54392       {
54393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54394       };
54395     }
54396   }
54397
54398 }
54399
54400
54401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54402   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54403   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54404
54405   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54406   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54407   {
54408     try {
54409       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54410     } catch (std::out_of_range& e) {
54411       {
54412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54413       };
54414     } catch (std::exception& e) {
54415       {
54416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54417       };
54418     } catch (Dali::DaliException e) {
54419       {
54420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54421       };
54422     } catch (...) {
54423       {
54424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54425       };
54426     }
54427   }
54428
54429 }
54430
54431
54432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54433   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54434   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54435
54436   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54437   arg2 = (Dali::RefObject *)jarg2;
54438   {
54439     try {
54440       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54441     } catch (std::out_of_range& e) {
54442       {
54443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54444       };
54445     } catch (std::exception& e) {
54446       {
54447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54448       };
54449     } catch (Dali::DaliException e) {
54450       {
54451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54452       };
54453     } catch (...) {
54454       {
54455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54456       };
54457     }
54458   }
54459
54460 }
54461
54462
54463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54464   void * jresult ;
54465   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54466
54467   {
54468     try {
54469       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54470     } catch (std::out_of_range& e) {
54471       {
54472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54473       };
54474     } catch (std::exception& e) {
54475       {
54476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54477       };
54478     } catch (Dali::DaliException e) {
54479       {
54480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54481       };
54482     } catch (...) {
54483       {
54484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54485       };
54486     }
54487   }
54488
54489   jresult = (void *)result;
54490   return jresult;
54491 }
54492
54493
54494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54495   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54496
54497   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54498   {
54499     try {
54500       delete arg1;
54501     } catch (std::out_of_range& e) {
54502       {
54503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54504       };
54505     } catch (std::exception& e) {
54506       {
54507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54508       };
54509     } catch (Dali::DaliException e) {
54510       {
54511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54512       };
54513     } catch (...) {
54514       {
54515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54516       };
54517     }
54518   }
54519
54520 }
54521
54522
54523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54524   unsigned int jresult ;
54525   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54526   bool result;
54527
54528   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54529   {
54530     try {
54531       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54532     } catch (std::out_of_range& e) {
54533       {
54534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54535       };
54536     } catch (std::exception& e) {
54537       {
54538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54539       };
54540     } catch (Dali::DaliException e) {
54541       {
54542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54543       };
54544     } catch (...) {
54545       {
54546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54547       };
54548     }
54549   }
54550
54551   jresult = result;
54552   return jresult;
54553 }
54554
54555
54556 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54557   unsigned long jresult ;
54558   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54559   std::size_t result;
54560
54561   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54562   {
54563     try {
54564       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54565     } catch (std::out_of_range& e) {
54566       {
54567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54568       };
54569     } catch (std::exception& e) {
54570       {
54571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54572       };
54573     } catch (Dali::DaliException e) {
54574       {
54575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54576       };
54577     } catch (...) {
54578       {
54579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54580       };
54581     }
54582   }
54583
54584   jresult = (unsigned long)result;
54585   return jresult;
54586 }
54587
54588
54589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54590   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54591   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54592
54593   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54594   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54595   {
54596     try {
54597       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54598     } catch (std::out_of_range& e) {
54599       {
54600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54601       };
54602     } catch (std::exception& e) {
54603       {
54604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54605       };
54606     } catch (Dali::DaliException e) {
54607       {
54608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54609       };
54610     } catch (...) {
54611       {
54612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54613       };
54614     }
54615   }
54616
54617 }
54618
54619
54620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54621   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54622   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54623
54624   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54625   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54626   {
54627     try {
54628       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54629     } catch (std::out_of_range& e) {
54630       {
54631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54632       };
54633     } catch (std::exception& e) {
54634       {
54635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54636       };
54637     } catch (Dali::DaliException e) {
54638       {
54639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54640       };
54641     } catch (...) {
54642       {
54643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54644       };
54645     }
54646   }
54647
54648 }
54649
54650
54651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54652   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54653   Dali::PropertyNotification *arg2 = 0 ;
54654
54655   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54656   arg2 = (Dali::PropertyNotification *)jarg2;
54657   if (!arg2) {
54658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54659     return ;
54660   }
54661   {
54662     try {
54663       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54664     } catch (std::out_of_range& e) {
54665       {
54666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54667       };
54668     } catch (std::exception& e) {
54669       {
54670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54671       };
54672     } catch (Dali::DaliException e) {
54673       {
54674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54675       };
54676     } catch (...) {
54677       {
54678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54679       };
54680     }
54681   }
54682
54683 }
54684
54685
54686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54687   void * jresult ;
54688   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54689
54690   {
54691     try {
54692       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54693     } catch (std::out_of_range& e) {
54694       {
54695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54696       };
54697     } catch (std::exception& e) {
54698       {
54699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54700       };
54701     } catch (Dali::DaliException e) {
54702       {
54703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54704       };
54705     } catch (...) {
54706       {
54707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54708       };
54709     }
54710   }
54711
54712   jresult = (void *)result;
54713   return jresult;
54714 }
54715
54716
54717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54718   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54719
54720   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54721   {
54722     try {
54723       delete arg1;
54724     } catch (std::out_of_range& e) {
54725       {
54726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54727       };
54728     } catch (std::exception& e) {
54729       {
54730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54731       };
54732     } catch (Dali::DaliException e) {
54733       {
54734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54735       };
54736     } catch (...) {
54737       {
54738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54739       };
54740     }
54741   }
54742
54743 }
54744
54745
54746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54747   unsigned int jresult ;
54748   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54749   bool result;
54750
54751   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54752   {
54753     try {
54754       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54755     } catch (std::out_of_range& e) {
54756       {
54757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54758       };
54759     } catch (std::exception& e) {
54760       {
54761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54762       };
54763     } catch (Dali::DaliException e) {
54764       {
54765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54766       };
54767     } catch (...) {
54768       {
54769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54770       };
54771     }
54772   }
54773
54774   jresult = result;
54775   return jresult;
54776 }
54777
54778
54779 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54780   unsigned long jresult ;
54781   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54782   std::size_t result;
54783
54784   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54785   {
54786     try {
54787       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54788     } catch (std::out_of_range& e) {
54789       {
54790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54791       };
54792     } catch (std::exception& e) {
54793       {
54794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54795       };
54796     } catch (Dali::DaliException e) {
54797       {
54798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54799       };
54800     } catch (...) {
54801       {
54802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54803       };
54804     }
54805   }
54806
54807   jresult = (unsigned long)result;
54808   return jresult;
54809 }
54810
54811
54812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54813   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54814   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54815
54816   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54817   arg2 = (void (*)(Dali::Image))jarg2;
54818   {
54819     try {
54820       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54821     } catch (std::out_of_range& e) {
54822       {
54823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54824       };
54825     } catch (std::exception& e) {
54826       {
54827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54828       };
54829     } catch (Dali::DaliException e) {
54830       {
54831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54832       };
54833     } catch (...) {
54834       {
54835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54836       };
54837     }
54838   }
54839
54840 }
54841
54842
54843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54844   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54845   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54846
54847   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54848   arg2 = (void (*)(Dali::Image))jarg2;
54849   {
54850     try {
54851       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54852     } catch (std::out_of_range& e) {
54853       {
54854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54855       };
54856     } catch (std::exception& e) {
54857       {
54858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54859       };
54860     } catch (Dali::DaliException e) {
54861       {
54862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54863       };
54864     } catch (...) {
54865       {
54866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54867       };
54868     }
54869   }
54870
54871 }
54872
54873
54874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54875   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54876   Dali::Image arg2 ;
54877   Dali::Image *argp2 ;
54878
54879   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54880   argp2 = (Dali::Image *)jarg2;
54881   if (!argp2) {
54882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54883     return ;
54884   }
54885   arg2 = *argp2;
54886   {
54887     try {
54888       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(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_new_ImageSignal() {
54912   void * jresult ;
54913   Dali::Signal< void (Dali::Image) > *result = 0 ;
54914
54915   {
54916     try {
54917       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
54918     } catch (std::out_of_range& e) {
54919       {
54920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54921       };
54922     } catch (std::exception& e) {
54923       {
54924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54925       };
54926     } catch (Dali::DaliException e) {
54927       {
54928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54929       };
54930     } catch (...) {
54931       {
54932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54933       };
54934     }
54935   }
54936
54937   jresult = (void *)result;
54938   return jresult;
54939 }
54940
54941
54942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
54943   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54944
54945   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54946   {
54947     try {
54948       delete arg1;
54949     } catch (std::out_of_range& e) {
54950       {
54951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54952       };
54953     } catch (std::exception& e) {
54954       {
54955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54956       };
54957     } catch (Dali::DaliException e) {
54958       {
54959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54960       };
54961     } catch (...) {
54962       {
54963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54964       };
54965     }
54966   }
54967
54968 }
54969
54970
54971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
54972   void * jresult ;
54973   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
54974
54975   {
54976     try {
54977       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
54978     } catch (std::out_of_range& e) {
54979       {
54980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54981       };
54982     } catch (std::exception& e) {
54983       {
54984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54985       };
54986     } catch (Dali::DaliException e) {
54987       {
54988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54989       };
54990     } catch (...) {
54991       {
54992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54993       };
54994     }
54995   }
54996
54997   jresult = (void *)result;
54998   return jresult;
54999 }
55000
55001
55002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55003   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55004
55005   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55006   {
55007     try {
55008       delete arg1;
55009     } catch (std::out_of_range& e) {
55010       {
55011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55012       };
55013     } catch (std::exception& e) {
55014       {
55015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55016       };
55017     } catch (Dali::DaliException e) {
55018       {
55019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55020       };
55021     } catch (...) {
55022       {
55023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55024       };
55025     }
55026   }
55027
55028 }
55029
55030
55031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55032   unsigned int jresult ;
55033   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55034   bool result;
55035
55036   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55037   {
55038     try {
55039       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);
55040     } catch (std::out_of_range& e) {
55041       {
55042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55043       };
55044     } catch (std::exception& e) {
55045       {
55046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55047       };
55048     } catch (Dali::DaliException e) {
55049       {
55050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55051       };
55052     } catch (...) {
55053       {
55054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55055       };
55056     }
55057   }
55058
55059   jresult = result;
55060   return jresult;
55061 }
55062
55063
55064 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55065   unsigned long jresult ;
55066   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55067   std::size_t result;
55068
55069   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55070   {
55071     try {
55072       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);
55073     } catch (std::out_of_range& e) {
55074       {
55075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55076       };
55077     } catch (std::exception& e) {
55078       {
55079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55080       };
55081     } catch (Dali::DaliException e) {
55082       {
55083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55084       };
55085     } catch (...) {
55086       {
55087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55088       };
55089     }
55090   }
55091
55092   jresult = (unsigned long)result;
55093   return jresult;
55094 }
55095
55096
55097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55098   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55099   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55100
55101   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55102   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55103   {
55104     try {
55105       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55106     } catch (std::out_of_range& e) {
55107       {
55108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55109       };
55110     } catch (std::exception& e) {
55111       {
55112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55113       };
55114     } catch (Dali::DaliException e) {
55115       {
55116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55117       };
55118     } catch (...) {
55119       {
55120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55121       };
55122     }
55123   }
55124
55125 }
55126
55127
55128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55129   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55130   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55131
55132   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55133   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55134   {
55135     try {
55136       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55137     } catch (std::out_of_range& e) {
55138       {
55139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55140       };
55141     } catch (std::exception& e) {
55142       {
55143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55144       };
55145     } catch (Dali::DaliException e) {
55146       {
55147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55148       };
55149     } catch (...) {
55150       {
55151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55152       };
55153     }
55154   }
55155
55156 }
55157
55158
55159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55160   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55161   Dali::Actor arg2 ;
55162   Dali::LongPressGesture *arg3 = 0 ;
55163   Dali::Actor *argp2 ;
55164
55165   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55166   argp2 = (Dali::Actor *)jarg2;
55167   if (!argp2) {
55168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55169     return ;
55170   }
55171   arg2 = *argp2;
55172   arg3 = (Dali::LongPressGesture *)jarg3;
55173   if (!arg3) {
55174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55175     return ;
55176   }
55177   {
55178     try {
55179       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55180     } catch (std::out_of_range& e) {
55181       {
55182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55183       };
55184     } catch (std::exception& e) {
55185       {
55186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55187       };
55188     } catch (Dali::DaliException e) {
55189       {
55190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55191       };
55192     } catch (...) {
55193       {
55194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55195       };
55196     }
55197   }
55198
55199 }
55200
55201
55202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55203   void * jresult ;
55204   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55205
55206   {
55207     try {
55208       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55209     } catch (std::out_of_range& e) {
55210       {
55211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55212       };
55213     } catch (std::exception& e) {
55214       {
55215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55216       };
55217     } catch (Dali::DaliException e) {
55218       {
55219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55220       };
55221     } catch (...) {
55222       {
55223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55224       };
55225     }
55226   }
55227
55228   jresult = (void *)result;
55229   return jresult;
55230 }
55231
55232
55233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55234   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55235
55236   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55237   {
55238     try {
55239       delete arg1;
55240     } catch (std::out_of_range& e) {
55241       {
55242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55243       };
55244     } catch (std::exception& e) {
55245       {
55246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55247       };
55248     } catch (Dali::DaliException e) {
55249       {
55250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55251       };
55252     } catch (...) {
55253       {
55254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55255       };
55256     }
55257   }
55258
55259 }
55260
55261
55262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55263   unsigned int jresult ;
55264   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55265   bool result;
55266
55267   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55268   {
55269     try {
55270       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);
55271     } catch (std::out_of_range& e) {
55272       {
55273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55274       };
55275     } catch (std::exception& e) {
55276       {
55277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55278       };
55279     } catch (Dali::DaliException e) {
55280       {
55281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55282       };
55283     } catch (...) {
55284       {
55285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55286       };
55287     }
55288   }
55289
55290   jresult = result;
55291   return jresult;
55292 }
55293
55294
55295 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55296   unsigned long jresult ;
55297   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55298   std::size_t result;
55299
55300   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55301   {
55302     try {
55303       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);
55304     } catch (std::out_of_range& e) {
55305       {
55306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55307       };
55308     } catch (std::exception& e) {
55309       {
55310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55311       };
55312     } catch (Dali::DaliException e) {
55313       {
55314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55315       };
55316     } catch (...) {
55317       {
55318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55319       };
55320     }
55321   }
55322
55323   jresult = (unsigned long)result;
55324   return jresult;
55325 }
55326
55327
55328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55329   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55330   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55331
55332   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55333   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55334   {
55335     try {
55336       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55337     } catch (std::out_of_range& e) {
55338       {
55339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55340       };
55341     } catch (std::exception& e) {
55342       {
55343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55344       };
55345     } catch (Dali::DaliException e) {
55346       {
55347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55348       };
55349     } catch (...) {
55350       {
55351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55352       };
55353     }
55354   }
55355
55356 }
55357
55358
55359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55360   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55361   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55362
55363   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55364   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55365   {
55366     try {
55367       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55368     } catch (std::out_of_range& e) {
55369       {
55370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55371       };
55372     } catch (std::exception& e) {
55373       {
55374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55375       };
55376     } catch (Dali::DaliException e) {
55377       {
55378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55379       };
55380     } catch (...) {
55381       {
55382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55383       };
55384     }
55385   }
55386
55387 }
55388
55389
55390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55391   unsigned int jresult ;
55392   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55393   Dali::Actor arg2 ;
55394   Dali::TouchData *arg3 = 0 ;
55395   Dali::Actor *argp2 ;
55396   bool result;
55397
55398   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55399   argp2 = (Dali::Actor *)jarg2;
55400   if (!argp2) {
55401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55402     return 0;
55403   }
55404   arg2 = *argp2;
55405   arg3 = (Dali::TouchData *)jarg3;
55406   if (!arg3) {
55407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55408     return 0;
55409   }
55410   {
55411     try {
55412       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55413     } catch (std::out_of_range& e) {
55414       {
55415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55416       };
55417     } catch (std::exception& e) {
55418       {
55419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55420       };
55421     } catch (Dali::DaliException e) {
55422       {
55423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55424       };
55425     } catch (...) {
55426       {
55427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55428       };
55429     }
55430   }
55431
55432   jresult = result;
55433   return jresult;
55434 }
55435
55436
55437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55438   void * jresult ;
55439   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55440
55441   {
55442     try {
55443       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55444     } catch (std::out_of_range& e) {
55445       {
55446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55447       };
55448     } catch (std::exception& e) {
55449       {
55450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55451       };
55452     } catch (Dali::DaliException e) {
55453       {
55454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55455       };
55456     } catch (...) {
55457       {
55458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55459       };
55460     }
55461   }
55462
55463   jresult = (void *)result;
55464   return jresult;
55465 }
55466
55467
55468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55469   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55470
55471   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55472   {
55473     try {
55474       delete arg1;
55475     } catch (std::out_of_range& e) {
55476       {
55477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55478       };
55479     } catch (std::exception& e) {
55480       {
55481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55482       };
55483     } catch (Dali::DaliException e) {
55484       {
55485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55486       };
55487     } catch (...) {
55488       {
55489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55490       };
55491     }
55492   }
55493
55494 }
55495
55496
55497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55498   unsigned int jresult ;
55499   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55500   bool result;
55501
55502   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55503   {
55504     try {
55505       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);
55506     } catch (std::out_of_range& e) {
55507       {
55508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55509       };
55510     } catch (std::exception& e) {
55511       {
55512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55513       };
55514     } catch (Dali::DaliException e) {
55515       {
55516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55517       };
55518     } catch (...) {
55519       {
55520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55521       };
55522     }
55523   }
55524
55525   jresult = result;
55526   return jresult;
55527 }
55528
55529
55530 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55531   unsigned long jresult ;
55532   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55533   std::size_t result;
55534
55535   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55536   {
55537     try {
55538       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);
55539     } catch (std::out_of_range& e) {
55540       {
55541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55542       };
55543     } catch (std::exception& e) {
55544       {
55545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55546       };
55547     } catch (Dali::DaliException e) {
55548       {
55549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55550       };
55551     } catch (...) {
55552       {
55553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55554       };
55555     }
55556   }
55557
55558   jresult = (unsigned long)result;
55559   return jresult;
55560 }
55561
55562
55563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55564   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55565   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55566
55567   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55568   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55569   {
55570     try {
55571       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55572     } catch (std::out_of_range& e) {
55573       {
55574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55575       };
55576     } catch (std::exception& e) {
55577       {
55578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55579       };
55580     } catch (Dali::DaliException e) {
55581       {
55582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55583       };
55584     } catch (...) {
55585       {
55586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55587       };
55588     }
55589   }
55590
55591 }
55592
55593
55594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55595   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55596   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55597
55598   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55599   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55600   {
55601     try {
55602       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55603     } catch (std::out_of_range& e) {
55604       {
55605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55606       };
55607     } catch (std::exception& e) {
55608       {
55609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55610       };
55611     } catch (Dali::DaliException e) {
55612       {
55613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55614       };
55615     } catch (...) {
55616       {
55617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55618       };
55619     }
55620   }
55621
55622 }
55623
55624
55625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55626   unsigned int jresult ;
55627   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55628   Dali::Actor arg2 ;
55629   Dali::HoverEvent *arg3 = 0 ;
55630   Dali::Actor *argp2 ;
55631   bool result;
55632
55633   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55634   argp2 = (Dali::Actor *)jarg2;
55635   if (!argp2) {
55636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55637     return 0;
55638   }
55639   arg2 = *argp2;
55640   arg3 = (Dali::HoverEvent *)jarg3;
55641   if (!arg3) {
55642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55643     return 0;
55644   }
55645   {
55646     try {
55647       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55648     } catch (std::out_of_range& e) {
55649       {
55650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55651       };
55652     } catch (std::exception& e) {
55653       {
55654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55655       };
55656     } catch (Dali::DaliException e) {
55657       {
55658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55659       };
55660     } catch (...) {
55661       {
55662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55663       };
55664     }
55665   }
55666
55667   jresult = result;
55668   return jresult;
55669 }
55670
55671
55672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55673   void * jresult ;
55674   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55675
55676   {
55677     try {
55678       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55679     } catch (std::out_of_range& e) {
55680       {
55681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55682       };
55683     } catch (std::exception& e) {
55684       {
55685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55686       };
55687     } catch (Dali::DaliException e) {
55688       {
55689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55690       };
55691     } catch (...) {
55692       {
55693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55694       };
55695     }
55696   }
55697
55698   jresult = (void *)result;
55699   return jresult;
55700 }
55701
55702
55703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55704   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55705
55706   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55707   {
55708     try {
55709       delete arg1;
55710     } catch (std::out_of_range& e) {
55711       {
55712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55713       };
55714     } catch (std::exception& e) {
55715       {
55716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55717       };
55718     } catch (Dali::DaliException e) {
55719       {
55720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55721       };
55722     } catch (...) {
55723       {
55724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55725       };
55726     }
55727   }
55728
55729 }
55730
55731
55732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55733   unsigned int jresult ;
55734   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55735   bool result;
55736
55737   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55738   {
55739     try {
55740       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);
55741     } catch (std::out_of_range& e) {
55742       {
55743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55744       };
55745     } catch (std::exception& e) {
55746       {
55747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55748       };
55749     } catch (Dali::DaliException e) {
55750       {
55751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55752       };
55753     } catch (...) {
55754       {
55755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55756       };
55757     }
55758   }
55759
55760   jresult = result;
55761   return jresult;
55762 }
55763
55764
55765 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55766   unsigned long jresult ;
55767   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55768   std::size_t result;
55769
55770   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55771   {
55772     try {
55773       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);
55774     } catch (std::out_of_range& e) {
55775       {
55776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55777       };
55778     } catch (std::exception& e) {
55779       {
55780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55781       };
55782     } catch (Dali::DaliException e) {
55783       {
55784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55785       };
55786     } catch (...) {
55787       {
55788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55789       };
55790     }
55791   }
55792
55793   jresult = (unsigned long)result;
55794   return jresult;
55795 }
55796
55797
55798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55799   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55800   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55801
55802   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55803   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55804   {
55805     try {
55806       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55807     } catch (std::out_of_range& e) {
55808       {
55809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55810       };
55811     } catch (std::exception& e) {
55812       {
55813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55814       };
55815     } catch (Dali::DaliException e) {
55816       {
55817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55818       };
55819     } catch (...) {
55820       {
55821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55822       };
55823     }
55824   }
55825
55826 }
55827
55828
55829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55830   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55831   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55832
55833   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55834   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55835   {
55836     try {
55837       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55838     } catch (std::out_of_range& e) {
55839       {
55840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55841       };
55842     } catch (std::exception& e) {
55843       {
55844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55845       };
55846     } catch (Dali::DaliException e) {
55847       {
55848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55849       };
55850     } catch (...) {
55851       {
55852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55853       };
55854     }
55855   }
55856
55857 }
55858
55859
55860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55861   unsigned int jresult ;
55862   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55863   Dali::Actor arg2 ;
55864   Dali::WheelEvent *arg3 = 0 ;
55865   Dali::Actor *argp2 ;
55866   bool result;
55867
55868   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55869   argp2 = (Dali::Actor *)jarg2;
55870   if (!argp2) {
55871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55872     return 0;
55873   }
55874   arg2 = *argp2;
55875   arg3 = (Dali::WheelEvent *)jarg3;
55876   if (!arg3) {
55877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55878     return 0;
55879   }
55880   {
55881     try {
55882       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55883     } catch (std::out_of_range& e) {
55884       {
55885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55886       };
55887     } catch (std::exception& e) {
55888       {
55889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55890       };
55891     } catch (Dali::DaliException e) {
55892       {
55893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55894       };
55895     } catch (...) {
55896       {
55897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55898       };
55899     }
55900   }
55901
55902   jresult = result;
55903   return jresult;
55904 }
55905
55906
55907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55908   void * jresult ;
55909   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55910
55911   {
55912     try {
55913       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55914     } catch (std::out_of_range& e) {
55915       {
55916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55917       };
55918     } catch (std::exception& e) {
55919       {
55920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55921       };
55922     } catch (Dali::DaliException e) {
55923       {
55924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55925       };
55926     } catch (...) {
55927       {
55928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55929       };
55930     }
55931   }
55932
55933   jresult = (void *)result;
55934   return jresult;
55935 }
55936
55937
55938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
55939   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55940
55941   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55942   {
55943     try {
55944       delete arg1;
55945     } catch (std::out_of_range& e) {
55946       {
55947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55948       };
55949     } catch (std::exception& e) {
55950       {
55951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55952       };
55953     } catch (Dali::DaliException e) {
55954       {
55955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55956       };
55957     } catch (...) {
55958       {
55959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55960       };
55961     }
55962   }
55963
55964 }
55965
55966
55967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
55968   unsigned int jresult ;
55969   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55970   bool result;
55971
55972   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55973   {
55974     try {
55975       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
55976     } catch (std::out_of_range& e) {
55977       {
55978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55979       };
55980     } catch (std::exception& e) {
55981       {
55982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55983       };
55984     } catch (Dali::DaliException e) {
55985       {
55986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55987       };
55988     } catch (...) {
55989       {
55990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55991       };
55992     }
55993   }
55994
55995   jresult = result;
55996   return jresult;
55997 }
55998
55999
56000 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56001   unsigned long jresult ;
56002   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56003   std::size_t result;
56004
56005   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56006   {
56007     try {
56008       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56009     } catch (std::out_of_range& e) {
56010       {
56011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56012       };
56013     } catch (std::exception& e) {
56014       {
56015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56016       };
56017     } catch (Dali::DaliException e) {
56018       {
56019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56020       };
56021     } catch (...) {
56022       {
56023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56024       };
56025     }
56026   }
56027
56028   jresult = (unsigned long)result;
56029   return jresult;
56030 }
56031
56032
56033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56034   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56035   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56036
56037   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56038   arg2 = (void (*)(Dali::Actor))jarg2;
56039   {
56040     try {
56041       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56042     } catch (std::out_of_range& e) {
56043       {
56044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56045       };
56046     } catch (std::exception& e) {
56047       {
56048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56049       };
56050     } catch (Dali::DaliException e) {
56051       {
56052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56053       };
56054     } catch (...) {
56055       {
56056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56057       };
56058     }
56059   }
56060
56061 }
56062
56063
56064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56065   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56066   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56067
56068   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56069   arg2 = (void (*)(Dali::Actor))jarg2;
56070   {
56071     try {
56072       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56073     } catch (std::out_of_range& e) {
56074       {
56075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56076       };
56077     } catch (std::exception& e) {
56078       {
56079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56080       };
56081     } catch (Dali::DaliException e) {
56082       {
56083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56084       };
56085     } catch (...) {
56086       {
56087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56088       };
56089     }
56090   }
56091
56092 }
56093
56094
56095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56096   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56097   Dali::Actor arg2 ;
56098   Dali::Actor *argp2 ;
56099
56100   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56101   argp2 = (Dali::Actor *)jarg2;
56102   if (!argp2) {
56103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56104     return ;
56105   }
56106   arg2 = *argp2;
56107   {
56108     try {
56109       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(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_new_ActorSignal() {
56133   void * jresult ;
56134   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56135
56136   {
56137     try {
56138       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56139     } catch (std::out_of_range& e) {
56140       {
56141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56142       };
56143     } catch (std::exception& e) {
56144       {
56145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56146       };
56147     } catch (Dali::DaliException e) {
56148       {
56149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56150       };
56151     } catch (...) {
56152       {
56153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56154       };
56155     }
56156   }
56157
56158   jresult = (void *)result;
56159   return jresult;
56160 }
56161
56162
56163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56164   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56165
56166   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56167   {
56168     try {
56169       delete arg1;
56170     } catch (std::out_of_range& e) {
56171       {
56172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56173       };
56174     } catch (std::exception& e) {
56175       {
56176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56177       };
56178     } catch (Dali::DaliException e) {
56179       {
56180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56181       };
56182     } catch (...) {
56183       {
56184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56185       };
56186     }
56187   }
56188
56189 }
56190
56191
56192 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56193   unsigned int jresult ;
56194   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56195   bool result;
56196
56197   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56198   {
56199     try {
56200       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56201     } catch (std::out_of_range& e) {
56202       {
56203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56204       };
56205     } catch (std::exception& e) {
56206       {
56207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56208       };
56209     } catch (Dali::DaliException e) {
56210       {
56211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56212       };
56213     } catch (...) {
56214       {
56215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56216       };
56217     }
56218   }
56219
56220   jresult = result;
56221   return jresult;
56222 }
56223
56224
56225 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56226   unsigned long jresult ;
56227   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56228   std::size_t result;
56229
56230   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56231   {
56232     try {
56233       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56234     } catch (std::out_of_range& e) {
56235       {
56236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56237       };
56238     } catch (std::exception& e) {
56239       {
56240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56241       };
56242     } catch (Dali::DaliException e) {
56243       {
56244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56245       };
56246     } catch (...) {
56247       {
56248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56249       };
56250     }
56251   }
56252
56253   jresult = (unsigned long)result;
56254   return jresult;
56255 }
56256
56257
56258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56259   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56260   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56261
56262   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56263   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56264   {
56265     try {
56266       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56267     } catch (std::out_of_range& e) {
56268       {
56269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56270       };
56271     } catch (std::exception& e) {
56272       {
56273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56274       };
56275     } catch (Dali::DaliException e) {
56276       {
56277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56278       };
56279     } catch (...) {
56280       {
56281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56282       };
56283     }
56284   }
56285
56286 }
56287
56288
56289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56290   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56291   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56292
56293   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56294   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56295   {
56296     try {
56297       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56298     } catch (std::out_of_range& e) {
56299       {
56300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56301       };
56302     } catch (std::exception& e) {
56303       {
56304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56305       };
56306     } catch (Dali::DaliException e) {
56307       {
56308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56309       };
56310     } catch (...) {
56311       {
56312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56313       };
56314     }
56315   }
56316
56317 }
56318
56319
56320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56321   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56322   Dali::KeyEvent *arg2 = 0 ;
56323
56324   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56325   arg2 = (Dali::KeyEvent *)jarg2;
56326   if (!arg2) {
56327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56328     return ;
56329   }
56330   {
56331     try {
56332       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56333     } catch (std::out_of_range& e) {
56334       {
56335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56336       };
56337     } catch (std::exception& e) {
56338       {
56339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56340       };
56341     } catch (Dali::DaliException e) {
56342       {
56343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56344       };
56345     } catch (...) {
56346       {
56347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56348       };
56349     }
56350   }
56351
56352 }
56353
56354
56355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56356   void * jresult ;
56357   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56358
56359   {
56360     try {
56361       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56362     } catch (std::out_of_range& e) {
56363       {
56364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56365       };
56366     } catch (std::exception& e) {
56367       {
56368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56369       };
56370     } catch (Dali::DaliException e) {
56371       {
56372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56373       };
56374     } catch (...) {
56375       {
56376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56377       };
56378     }
56379   }
56380
56381   jresult = (void *)result;
56382   return jresult;
56383 }
56384
56385
56386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56387   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56388
56389   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56390   {
56391     try {
56392       delete arg1;
56393     } catch (std::out_of_range& e) {
56394       {
56395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56396       };
56397     } catch (std::exception& e) {
56398       {
56399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56400       };
56401     } catch (Dali::DaliException e) {
56402       {
56403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56404       };
56405     } catch (...) {
56406       {
56407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56408       };
56409     }
56410   }
56411
56412 }
56413
56414
56415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56416   unsigned int jresult ;
56417   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56418   bool result;
56419
56420   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56421   {
56422     try {
56423       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56424     } catch (std::out_of_range& e) {
56425       {
56426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56427       };
56428     } catch (std::exception& e) {
56429       {
56430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56431       };
56432     } catch (Dali::DaliException e) {
56433       {
56434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56435       };
56436     } catch (...) {
56437       {
56438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56439       };
56440     }
56441   }
56442
56443   jresult = result;
56444   return jresult;
56445 }
56446
56447
56448 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56449   unsigned long jresult ;
56450   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56451   std::size_t result;
56452
56453   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56454   {
56455     try {
56456       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56457     } catch (std::out_of_range& e) {
56458       {
56459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56460       };
56461     } catch (std::exception& e) {
56462       {
56463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56464       };
56465     } catch (Dali::DaliException e) {
56466       {
56467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56468       };
56469     } catch (...) {
56470       {
56471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56472       };
56473     }
56474   }
56475
56476   jresult = (unsigned long)result;
56477   return jresult;
56478 }
56479
56480
56481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56482   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56483   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56484
56485   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56486   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56487   {
56488     try {
56489       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56490     } catch (std::out_of_range& e) {
56491       {
56492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56493       };
56494     } catch (std::exception& e) {
56495       {
56496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56497       };
56498     } catch (Dali::DaliException e) {
56499       {
56500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56501       };
56502     } catch (...) {
56503       {
56504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56505       };
56506     }
56507   }
56508
56509 }
56510
56511
56512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56513   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56514   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56515
56516   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56517   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56518   {
56519     try {
56520       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56521     } catch (std::out_of_range& e) {
56522       {
56523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56524       };
56525     } catch (std::exception& e) {
56526       {
56527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56528       };
56529     } catch (Dali::DaliException e) {
56530       {
56531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56532       };
56533     } catch (...) {
56534       {
56535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56536       };
56537     }
56538   }
56539
56540 }
56541
56542
56543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56544   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56545   Dali::TouchData *arg2 = 0 ;
56546
56547   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56548   arg2 = (Dali::TouchData *)jarg2;
56549   if (!arg2) {
56550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56551     return ;
56552   }
56553   {
56554     try {
56555       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56556     } catch (std::out_of_range& e) {
56557       {
56558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56559       };
56560     } catch (std::exception& e) {
56561       {
56562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56563       };
56564     } catch (Dali::DaliException e) {
56565       {
56566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56567       };
56568     } catch (...) {
56569       {
56570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56571       };
56572     }
56573   }
56574
56575 }
56576
56577
56578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56579   void * jresult ;
56580   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56581
56582   {
56583     try {
56584       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56585     } catch (std::out_of_range& e) {
56586       {
56587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56588       };
56589     } catch (std::exception& e) {
56590       {
56591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56592       };
56593     } catch (Dali::DaliException e) {
56594       {
56595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56596       };
56597     } catch (...) {
56598       {
56599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56600       };
56601     }
56602   }
56603
56604   jresult = (void *)result;
56605   return jresult;
56606 }
56607
56608
56609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56610   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56611
56612   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56613   {
56614     try {
56615       delete arg1;
56616     } catch (std::out_of_range& e) {
56617       {
56618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56619       };
56620     } catch (std::exception& e) {
56621       {
56622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56623       };
56624     } catch (Dali::DaliException e) {
56625       {
56626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56627       };
56628     } catch (...) {
56629       {
56630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56631       };
56632     }
56633   }
56634
56635 }
56636
56637
56638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56639   unsigned int jresult ;
56640   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56641   bool result;
56642
56643   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56644   {
56645     try {
56646       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56647     } catch (std::out_of_range& e) {
56648       {
56649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56650       };
56651     } catch (std::exception& e) {
56652       {
56653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56654       };
56655     } catch (Dali::DaliException e) {
56656       {
56657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56658       };
56659     } catch (...) {
56660       {
56661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56662       };
56663     }
56664   }
56665
56666   jresult = result;
56667   return jresult;
56668 }
56669
56670
56671 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56672   unsigned long jresult ;
56673   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56674   std::size_t result;
56675
56676   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56677   {
56678     try {
56679       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56680     } catch (std::out_of_range& e) {
56681       {
56682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56683       };
56684     } catch (std::exception& e) {
56685       {
56686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56687       };
56688     } catch (Dali::DaliException e) {
56689       {
56690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56691       };
56692     } catch (...) {
56693       {
56694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56695       };
56696     }
56697   }
56698
56699   jresult = (unsigned long)result;
56700   return jresult;
56701 }
56702
56703
56704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56705   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56706   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56707
56708   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56709   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56710   {
56711     try {
56712       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56713     } catch (std::out_of_range& e) {
56714       {
56715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56716       };
56717     } catch (std::exception& e) {
56718       {
56719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56720       };
56721     } catch (Dali::DaliException e) {
56722       {
56723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56724       };
56725     } catch (...) {
56726       {
56727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56728       };
56729     }
56730   }
56731
56732 }
56733
56734
56735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56736   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56737   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56738
56739   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56740   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56741   {
56742     try {
56743       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56744     } catch (std::out_of_range& e) {
56745       {
56746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56747       };
56748     } catch (std::exception& e) {
56749       {
56750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56751       };
56752     } catch (Dali::DaliException e) {
56753       {
56754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56755       };
56756     } catch (...) {
56757       {
56758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56759       };
56760     }
56761   }
56762
56763 }
56764
56765
56766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56767   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56768   Dali::WheelEvent *arg2 = 0 ;
56769
56770   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56771   arg2 = (Dali::WheelEvent *)jarg2;
56772   if (!arg2) {
56773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56774     return ;
56775   }
56776   {
56777     try {
56778       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56779     } catch (std::out_of_range& e) {
56780       {
56781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56782       };
56783     } catch (std::exception& e) {
56784       {
56785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56786       };
56787     } catch (Dali::DaliException e) {
56788       {
56789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56790       };
56791     } catch (...) {
56792       {
56793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56794       };
56795     }
56796   }
56797
56798 }
56799
56800
56801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56802   void * jresult ;
56803   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56804
56805   {
56806     try {
56807       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56808     } catch (std::out_of_range& e) {
56809       {
56810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56811       };
56812     } catch (std::exception& e) {
56813       {
56814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56815       };
56816     } catch (Dali::DaliException e) {
56817       {
56818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56819       };
56820     } catch (...) {
56821       {
56822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56823       };
56824     }
56825   }
56826
56827   jresult = (void *)result;
56828   return jresult;
56829 }
56830
56831
56832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56833   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56834
56835   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56836   {
56837     try {
56838       delete arg1;
56839     } catch (std::out_of_range& e) {
56840       {
56841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56842       };
56843     } catch (std::exception& e) {
56844       {
56845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56846       };
56847     } catch (Dali::DaliException e) {
56848       {
56849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56850       };
56851     } catch (...) {
56852       {
56853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56854       };
56855     }
56856   }
56857
56858 }
56859
56860
56861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56862   void * jresult ;
56863   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56864
56865   {
56866     try {
56867       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56868     } catch (std::out_of_range& e) {
56869       {
56870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56871       };
56872     } catch (std::exception& e) {
56873       {
56874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56875       };
56876     } catch (Dali::DaliException e) {
56877       {
56878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56879       };
56880     } catch (...) {
56881       {
56882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56883       };
56884     }
56885   }
56886
56887   jresult = (void *)result;
56888   return jresult;
56889 }
56890
56891
56892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56893   void * jresult ;
56894   Dali::Radian arg1 ;
56895   Dali::Radian arg2 ;
56896   Dali::Radian *argp1 ;
56897   Dali::Radian *argp2 ;
56898   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56899
56900   argp1 = (Dali::Radian *)jarg1;
56901   if (!argp1) {
56902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56903     return 0;
56904   }
56905   arg1 = *argp1;
56906   argp2 = (Dali::Radian *)jarg2;
56907   if (!argp2) {
56908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56909     return 0;
56910   }
56911   arg2 = *argp2;
56912   {
56913     try {
56914       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
56915     } catch (std::out_of_range& e) {
56916       {
56917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56918       };
56919     } catch (std::exception& e) {
56920       {
56921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56922       };
56923     } catch (Dali::DaliException e) {
56924       {
56925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56926       };
56927     } catch (...) {
56928       {
56929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56930       };
56931     }
56932   }
56933
56934   jresult = (void *)result;
56935   return jresult;
56936 }
56937
56938
56939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
56940   void * jresult ;
56941   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
56942   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56943
56944   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56945   if (!arg1) {
56946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
56947     return 0;
56948   }
56949   {
56950     try {
56951       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
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_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
56977   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56978   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56979
56980   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56981   arg2 = (Dali::Radian *)jarg2;
56982   if (arg1) (arg1)->first = *arg2;
56983 }
56984
56985
56986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
56987   void * jresult ;
56988   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56989   Dali::Radian *result = 0 ;
56990
56991   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56992   result = (Dali::Radian *)& ((arg1)->first);
56993   jresult = (void *)result;
56994   return jresult;
56995 }
56996
56997
56998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
56999   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57000   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57001
57002   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57003   arg2 = (Dali::Radian *)jarg2;
57004   if (arg1) (arg1)->second = *arg2;
57005 }
57006
57007
57008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57009   void * jresult ;
57010   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57011   Dali::Radian *result = 0 ;
57012
57013   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57014   result = (Dali::Radian *)& ((arg1)->second);
57015   jresult = (void *)result;
57016   return jresult;
57017 }
57018
57019
57020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57021   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57022
57023   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57024   {
57025     try {
57026       delete arg1;
57027     } catch (std::out_of_range& e) {
57028       {
57029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57030       };
57031     } catch (std::exception& e) {
57032       {
57033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57034       };
57035     } catch (Dali::DaliException e) {
57036       {
57037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57038       };
57039     } catch (...) {
57040       {
57041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57042       };
57043     }
57044   }
57045
57046 }
57047
57048
57049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57050   unsigned int jresult ;
57051   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57052   bool result;
57053
57054   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57055   {
57056     try {
57057       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);
57058     } catch (std::out_of_range& e) {
57059       {
57060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57061       };
57062     } catch (std::exception& e) {
57063       {
57064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57065       };
57066     } catch (Dali::DaliException e) {
57067       {
57068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57069       };
57070     } catch (...) {
57071       {
57072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57073       };
57074     }
57075   }
57076
57077   jresult = result;
57078   return jresult;
57079 }
57080
57081
57082 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57083   unsigned long jresult ;
57084   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57085   std::size_t result;
57086
57087   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57088   {
57089     try {
57090       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);
57091     } catch (std::out_of_range& e) {
57092       {
57093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57094       };
57095     } catch (std::exception& e) {
57096       {
57097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57098       };
57099     } catch (Dali::DaliException e) {
57100       {
57101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57102       };
57103     } catch (...) {
57104       {
57105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57106       };
57107     }
57108   }
57109
57110   jresult = (unsigned long)result;
57111   return jresult;
57112 }
57113
57114
57115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57116   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57117   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57118
57119   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57120   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57121   {
57122     try {
57123       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57124     } catch (std::out_of_range& e) {
57125       {
57126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57127       };
57128     } catch (std::exception& e) {
57129       {
57130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57131       };
57132     } catch (Dali::DaliException e) {
57133       {
57134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57135       };
57136     } catch (...) {
57137       {
57138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57139       };
57140     }
57141   }
57142
57143 }
57144
57145
57146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57147   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57148   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57149
57150   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57151   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57152   {
57153     try {
57154       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57155     } catch (std::out_of_range& e) {
57156       {
57157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57158       };
57159     } catch (std::exception& e) {
57160       {
57161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57162       };
57163     } catch (Dali::DaliException e) {
57164       {
57165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57166       };
57167     } catch (...) {
57168       {
57169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57170       };
57171     }
57172   }
57173
57174 }
57175
57176
57177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57178   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57179   Dali::Actor arg2 ;
57180   Dali::PanGesture *arg3 = 0 ;
57181   Dali::Actor *argp2 ;
57182
57183   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57184   argp2 = (Dali::Actor *)jarg2;
57185   if (!argp2) {
57186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57187     return ;
57188   }
57189   arg2 = *argp2;
57190   arg3 = (Dali::PanGesture *)jarg3;
57191   if (!arg3) {
57192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57193     return ;
57194   }
57195   {
57196     try {
57197       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57198     } catch (std::out_of_range& e) {
57199       {
57200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57201       };
57202     } catch (std::exception& e) {
57203       {
57204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57205       };
57206     } catch (Dali::DaliException e) {
57207       {
57208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57209       };
57210     } catch (...) {
57211       {
57212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57213       };
57214     }
57215   }
57216
57217 }
57218
57219
57220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57221   void * jresult ;
57222   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57223
57224   {
57225     try {
57226       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57227     } catch (std::out_of_range& e) {
57228       {
57229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57230       };
57231     } catch (std::exception& e) {
57232       {
57233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57234       };
57235     } catch (Dali::DaliException e) {
57236       {
57237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57238       };
57239     } catch (...) {
57240       {
57241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57242       };
57243     }
57244   }
57245
57246   jresult = (void *)result;
57247   return jresult;
57248 }
57249
57250
57251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57252   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57253
57254   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57255   {
57256     try {
57257       delete arg1;
57258     } catch (std::out_of_range& e) {
57259       {
57260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57261       };
57262     } catch (std::exception& e) {
57263       {
57264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57265       };
57266     } catch (Dali::DaliException e) {
57267       {
57268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57269       };
57270     } catch (...) {
57271       {
57272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57273       };
57274     }
57275   }
57276
57277 }
57278
57279
57280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57281   unsigned int jresult ;
57282   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57283   bool result;
57284
57285   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57286   {
57287     try {
57288       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);
57289     } catch (std::out_of_range& e) {
57290       {
57291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57292       };
57293     } catch (std::exception& e) {
57294       {
57295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57296       };
57297     } catch (Dali::DaliException e) {
57298       {
57299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57300       };
57301     } catch (...) {
57302       {
57303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57304       };
57305     }
57306   }
57307
57308   jresult = result;
57309   return jresult;
57310 }
57311
57312
57313 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57314   unsigned long jresult ;
57315   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57316   std::size_t result;
57317
57318   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57319   {
57320     try {
57321       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);
57322     } catch (std::out_of_range& e) {
57323       {
57324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57325       };
57326     } catch (std::exception& e) {
57327       {
57328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57329       };
57330     } catch (Dali::DaliException e) {
57331       {
57332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57333       };
57334     } catch (...) {
57335       {
57336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57337       };
57338     }
57339   }
57340
57341   jresult = (unsigned long)result;
57342   return jresult;
57343 }
57344
57345
57346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57347   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57348   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57349
57350   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57351   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57352   {
57353     try {
57354       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57355     } catch (std::out_of_range& e) {
57356       {
57357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57358       };
57359     } catch (std::exception& e) {
57360       {
57361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57362       };
57363     } catch (Dali::DaliException e) {
57364       {
57365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57366       };
57367     } catch (...) {
57368       {
57369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57370       };
57371     }
57372   }
57373
57374 }
57375
57376
57377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57378   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57379   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57380
57381   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57382   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57383   {
57384     try {
57385       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57386     } catch (std::out_of_range& e) {
57387       {
57388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57389       };
57390     } catch (std::exception& e) {
57391       {
57392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57393       };
57394     } catch (Dali::DaliException e) {
57395       {
57396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57397       };
57398     } catch (...) {
57399       {
57400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57401       };
57402     }
57403   }
57404
57405 }
57406
57407
57408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57409   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57410   Dali::Actor arg2 ;
57411   Dali::PinchGesture *arg3 = 0 ;
57412   Dali::Actor *argp2 ;
57413
57414   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57415   argp2 = (Dali::Actor *)jarg2;
57416   if (!argp2) {
57417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57418     return ;
57419   }
57420   arg2 = *argp2;
57421   arg3 = (Dali::PinchGesture *)jarg3;
57422   if (!arg3) {
57423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57424     return ;
57425   }
57426   {
57427     try {
57428       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57429     } catch (std::out_of_range& e) {
57430       {
57431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57432       };
57433     } catch (std::exception& e) {
57434       {
57435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57436       };
57437     } catch (Dali::DaliException e) {
57438       {
57439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57440       };
57441     } catch (...) {
57442       {
57443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57444       };
57445     }
57446   }
57447
57448 }
57449
57450
57451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57452   void * jresult ;
57453   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57454
57455   {
57456     try {
57457       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57458     } catch (std::out_of_range& e) {
57459       {
57460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57461       };
57462     } catch (std::exception& e) {
57463       {
57464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57465       };
57466     } catch (Dali::DaliException e) {
57467       {
57468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57469       };
57470     } catch (...) {
57471       {
57472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57473       };
57474     }
57475   }
57476
57477   jresult = (void *)result;
57478   return jresult;
57479 }
57480
57481
57482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57483   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57484
57485   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57486   {
57487     try {
57488       delete arg1;
57489     } catch (std::out_of_range& e) {
57490       {
57491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57492       };
57493     } catch (std::exception& e) {
57494       {
57495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57496       };
57497     } catch (Dali::DaliException e) {
57498       {
57499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57500       };
57501     } catch (...) {
57502       {
57503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57504       };
57505     }
57506   }
57507
57508 }
57509
57510
57511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57512   unsigned int jresult ;
57513   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57514   bool result;
57515
57516   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57517   {
57518     try {
57519       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);
57520     } catch (std::out_of_range& e) {
57521       {
57522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57523       };
57524     } catch (std::exception& e) {
57525       {
57526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57527       };
57528     } catch (Dali::DaliException e) {
57529       {
57530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57531       };
57532     } catch (...) {
57533       {
57534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57535       };
57536     }
57537   }
57538
57539   jresult = result;
57540   return jresult;
57541 }
57542
57543
57544 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57545   unsigned long jresult ;
57546   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57547   std::size_t result;
57548
57549   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57550   {
57551     try {
57552       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);
57553     } catch (std::out_of_range& e) {
57554       {
57555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57556       };
57557     } catch (std::exception& e) {
57558       {
57559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57560       };
57561     } catch (Dali::DaliException e) {
57562       {
57563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57564       };
57565     } catch (...) {
57566       {
57567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57568       };
57569     }
57570   }
57571
57572   jresult = (unsigned long)result;
57573   return jresult;
57574 }
57575
57576
57577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57578   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57579   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57580
57581   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57582   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57583   {
57584     try {
57585       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57586     } catch (std::out_of_range& e) {
57587       {
57588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57589       };
57590     } catch (std::exception& e) {
57591       {
57592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57593       };
57594     } catch (Dali::DaliException e) {
57595       {
57596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57597       };
57598     } catch (...) {
57599       {
57600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57601       };
57602     }
57603   }
57604
57605 }
57606
57607
57608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57609   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57610   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57611
57612   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57613   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57614   {
57615     try {
57616       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57617     } catch (std::out_of_range& e) {
57618       {
57619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57620       };
57621     } catch (std::exception& e) {
57622       {
57623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57624       };
57625     } catch (Dali::DaliException e) {
57626       {
57627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57628       };
57629     } catch (...) {
57630       {
57631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57632       };
57633     }
57634   }
57635
57636 }
57637
57638
57639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57640   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57641   Dali::Actor arg2 ;
57642   Dali::TapGesture *arg3 = 0 ;
57643   Dali::Actor *argp2 ;
57644
57645   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57646   argp2 = (Dali::Actor *)jarg2;
57647   if (!argp2) {
57648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57649     return ;
57650   }
57651   arg2 = *argp2;
57652   arg3 = (Dali::TapGesture *)jarg3;
57653   if (!arg3) {
57654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57655     return ;
57656   }
57657   {
57658     try {
57659       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57660     } catch (std::out_of_range& e) {
57661       {
57662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57663       };
57664     } catch (std::exception& e) {
57665       {
57666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57667       };
57668     } catch (Dali::DaliException e) {
57669       {
57670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57671       };
57672     } catch (...) {
57673       {
57674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57675       };
57676     }
57677   }
57678
57679 }
57680
57681
57682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57683   void * jresult ;
57684   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57685
57686   {
57687     try {
57688       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57689     } catch (std::out_of_range& e) {
57690       {
57691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57692       };
57693     } catch (std::exception& e) {
57694       {
57695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57696       };
57697     } catch (Dali::DaliException e) {
57698       {
57699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57700       };
57701     } catch (...) {
57702       {
57703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57704       };
57705     }
57706   }
57707
57708   jresult = (void *)result;
57709   return jresult;
57710 }
57711
57712
57713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57714   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57715
57716   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57717   {
57718     try {
57719       delete arg1;
57720     } catch (std::out_of_range& e) {
57721       {
57722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57723       };
57724     } catch (std::exception& e) {
57725       {
57726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57727       };
57728     } catch (Dali::DaliException e) {
57729       {
57730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57731       };
57732     } catch (...) {
57733       {
57734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57735       };
57736     }
57737   }
57738
57739 }
57740
57741 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57742   unsigned int jresult ;
57743   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57744   bool result;
57745
57746   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57747   {
57748     try {
57749       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57750     } catch (std::out_of_range& e) {
57751       {
57752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57753       };
57754     } catch (std::exception& e) {
57755       {
57756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57757       };
57758     } catch (Dali::DaliException e) {
57759       {
57760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57761       };
57762     } catch (...) {
57763       {
57764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57765       };
57766     }
57767   }
57768
57769   jresult = result;
57770   return jresult;
57771 }
57772
57773
57774 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57775   unsigned long jresult ;
57776   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57777   std::size_t result;
57778
57779   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57780   {
57781     try {
57782       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57783     } catch (std::out_of_range& e) {
57784       {
57785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57786       };
57787     } catch (std::exception& e) {
57788       {
57789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57790       };
57791     } catch (Dali::DaliException e) {
57792       {
57793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57794       };
57795     } catch (...) {
57796       {
57797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57798       };
57799     }
57800   }
57801
57802   jresult = (unsigned long)result;
57803   return jresult;
57804 }
57805
57806
57807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57808   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57809   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57810
57811   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57812   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57813   {
57814     try {
57815       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57816     } catch (std::out_of_range& e) {
57817       {
57818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57819       };
57820     } catch (std::exception& e) {
57821       {
57822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57823       };
57824     } catch (Dali::DaliException e) {
57825       {
57826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57827       };
57828     } catch (...) {
57829       {
57830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57831       };
57832     }
57833   }
57834
57835 }
57836
57837
57838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57839   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57840   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57841
57842   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57843   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57844   {
57845     try {
57846       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57847     } catch (std::out_of_range& e) {
57848       {
57849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57850       };
57851     } catch (std::exception& e) {
57852       {
57853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57854       };
57855     } catch (Dali::DaliException e) {
57856       {
57857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57858       };
57859     } catch (...) {
57860       {
57861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57862       };
57863     }
57864   }
57865
57866 }
57867
57868
57869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57870   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57871   Dali::ResourceImage arg2 ;
57872   Dali::ResourceImage *argp2 ;
57873
57874   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57875   argp2 = (Dali::ResourceImage *)jarg2;
57876   if (!argp2) {
57877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57878     return ;
57879   }
57880   arg2 = *argp2;
57881   {
57882     try {
57883       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(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_new_ResourceImageSignal() {
57907   void * jresult ;
57908   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57909
57910   {
57911     try {
57912       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57913     } catch (std::out_of_range& e) {
57914       {
57915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57916       };
57917     } catch (std::exception& e) {
57918       {
57919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57920       };
57921     } catch (Dali::DaliException e) {
57922       {
57923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57924       };
57925     } catch (...) {
57926       {
57927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57928       };
57929     }
57930   }
57931
57932   jresult = (void *)result;
57933   return jresult;
57934 }
57935
57936
57937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
57938   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57939
57940   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57941   {
57942     try {
57943       delete arg1;
57944     } catch (std::out_of_range& e) {
57945       {
57946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57947       };
57948     } catch (std::exception& e) {
57949       {
57950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57951       };
57952     } catch (Dali::DaliException e) {
57953       {
57954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57955       };
57956     } catch (...) {
57957       {
57958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57959       };
57960     }
57961   }
57962
57963 }
57964
57965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
57966   unsigned int jresult ;
57967   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57968   bool result = false;
57969
57970   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57971   {
57972     try {
57973       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);
57974     } catch (std::out_of_range& e) {
57975       {
57976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57977       };
57978     } catch (std::exception& e) {
57979       {
57980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57981       };
57982     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57983   }
57984   jresult = result;
57985   return jresult;
57986 }
57987
57988 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
57989   unsigned long jresult ;
57990   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57991   std::size_t result = 0;
57992
57993   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57994   {
57995     try {
57996       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);
57997     } catch (std::out_of_range& e) {
57998       {
57999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58000       };
58001     } catch (std::exception& e) {
58002       {
58003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58004       };
58005     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58006   }
58007   jresult = (unsigned long)result;
58008   return jresult;
58009 }
58010
58011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58012   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58013   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58014
58015   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58016   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58017   {
58018     try {
58019       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58020     } catch (std::out_of_range& e) {
58021       {
58022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58023       };
58024     } catch (std::exception& e) {
58025       {
58026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58027       };
58028     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58029   }
58030 }
58031
58032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58033   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58034   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58035
58036   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58037   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58038   {
58039     try {
58040       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58041     } catch (std::out_of_range& e) {
58042       {
58043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58044       };
58045     } catch (std::exception& e) {
58046       {
58047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58048       };
58049     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58050   }
58051 }
58052
58053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58054   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58055   Dali::Actor arg2 ;
58056   //bool arg3 ;
58057   Dali::LayoutDirection::Type arg4 ;
58058   Dali::Actor *argp2 ;
58059
58060   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58061   argp2 = (Dali::Actor *)jarg2;
58062   if (!argp2) {
58063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58064     return ;
58065   }
58066   arg2 = *argp2;
58067   //arg3 = jarg3 ? true : false;
58068   arg4 = (Dali::LayoutDirection::Type)jarg4;
58069   {
58070     try {
58071       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58072     } catch (std::out_of_range& e) {
58073       {
58074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58075       };
58076     } catch (std::exception& e) {
58077       {
58078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58079       };
58080     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58081   }
58082 }
58083
58084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58085   void * jresult ;
58086   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58087
58088   {
58089     try {
58090       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58091     } catch (std::out_of_range& e) {
58092       {
58093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58094       };
58095     } catch (std::exception& e) {
58096       {
58097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58098       };
58099     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58100   }
58101   jresult = (void *)result;
58102   return jresult;
58103 }
58104
58105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58106   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58107
58108   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58109   {
58110     try {
58111       delete arg1;
58112     } catch (std::out_of_range& e) {
58113       {
58114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58115       };
58116     } catch (std::exception& e) {
58117       {
58118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58119       };
58120     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58121   }
58122 }
58123
58124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58125   unsigned int jresult ;
58126   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58127   bool result;
58128
58129   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58130   {
58131     try {
58132       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);
58133     } catch (std::out_of_range& e) {
58134       {
58135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58136       };
58137     } catch (std::exception& e) {
58138       {
58139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58140       };
58141     } catch (Dali::DaliException e) {
58142       {
58143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58144       };
58145     } catch (...) {
58146       {
58147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58148       };
58149     }
58150   }
58151
58152   jresult = result;
58153   return jresult;
58154 }
58155
58156
58157 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58158   unsigned long jresult ;
58159   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58160   std::size_t result;
58161
58162   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58163   {
58164     try {
58165       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);
58166     } catch (std::out_of_range& e) {
58167       {
58168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58169       };
58170     } catch (std::exception& e) {
58171       {
58172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58173       };
58174     } catch (Dali::DaliException e) {
58175       {
58176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58177       };
58178     } catch (...) {
58179       {
58180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58181       };
58182     }
58183   }
58184
58185   jresult = (unsigned long)result;
58186   return jresult;
58187 }
58188
58189
58190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58191   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58192   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58193
58194   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58195   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58196   {
58197     try {
58198       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58199     } catch (std::out_of_range& e) {
58200       {
58201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58202       };
58203     } catch (std::exception& e) {
58204       {
58205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58206       };
58207     } catch (Dali::DaliException e) {
58208       {
58209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58210       };
58211     } catch (...) {
58212       {
58213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58214       };
58215     }
58216   }
58217
58218 }
58219
58220
58221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58222   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58223   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58224
58225   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58226   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58227   {
58228     try {
58229       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58230     } catch (std::out_of_range& e) {
58231       {
58232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58233       };
58234     } catch (std::exception& e) {
58235       {
58236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58237       };
58238     } catch (Dali::DaliException e) {
58239       {
58240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58241       };
58242     } catch (...) {
58243       {
58244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58245       };
58246     }
58247   }
58248
58249 }
58250
58251
58252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58253   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58254   Dali::Actor arg2 ;
58255   bool arg3 ;
58256   Dali::DevelActor::VisibilityChange::Type arg4 ;
58257   Dali::Actor *argp2 ;
58258
58259   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58260   argp2 = (Dali::Actor *)jarg2;
58261   if (!argp2) {
58262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58263     return ;
58264   }
58265   arg2 = *argp2;
58266   arg3 = jarg3 ? true : false;
58267   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58268   {
58269     try {
58270       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58271     } catch (std::out_of_range& e) {
58272       {
58273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58274       };
58275     } catch (std::exception& e) {
58276       {
58277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58278       };
58279     } catch (Dali::DaliException e) {
58280       {
58281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58282       };
58283     } catch (...) {
58284       {
58285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58286       };
58287     }
58288   }
58289
58290 }
58291
58292
58293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58294   void * jresult ;
58295   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58296
58297   {
58298     try {
58299       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58300     } catch (std::out_of_range& e) {
58301       {
58302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58303       };
58304     } catch (std::exception& e) {
58305       {
58306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58307       };
58308     } catch (Dali::DaliException e) {
58309       {
58310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58311       };
58312     } catch (...) {
58313       {
58314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58315       };
58316     }
58317   }
58318
58319   jresult = (void *)result;
58320   return jresult;
58321 }
58322
58323
58324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58325   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58326
58327   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58328   {
58329     try {
58330       delete arg1;
58331     } catch (std::out_of_range& e) {
58332       {
58333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58334       };
58335     } catch (std::exception& e) {
58336       {
58337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58338       };
58339     } catch (Dali::DaliException e) {
58340       {
58341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58342       };
58343     } catch (...) {
58344       {
58345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58346       };
58347     }
58348   }
58349
58350 }
58351
58352
58353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58354   void * jresult ;
58355   Dali::Timer *result = 0 ;
58356
58357   {
58358     try {
58359       result = (Dali::Timer *)new Dali::Timer();
58360     } catch (std::out_of_range& e) {
58361       {
58362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58363       };
58364     } catch (std::exception& e) {
58365       {
58366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58367       };
58368     } catch (Dali::DaliException e) {
58369       {
58370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58371       };
58372     } catch (...) {
58373       {
58374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58375       };
58376     }
58377   }
58378
58379   jresult = (void *)result;
58380   return jresult;
58381 }
58382
58383
58384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58385   void * jresult ;
58386   unsigned int arg1 ;
58387   Dali::Timer result;
58388
58389   arg1 = (unsigned int)jarg1;
58390   {
58391     try {
58392       result = Dali::Timer::New(arg1);
58393     } catch (std::out_of_range& e) {
58394       {
58395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58396       };
58397     } catch (std::exception& e) {
58398       {
58399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58400       };
58401     } catch (Dali::DaliException e) {
58402       {
58403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58404       };
58405     } catch (...) {
58406       {
58407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58408       };
58409     }
58410   }
58411
58412   jresult = new Dali::Timer((const Dali::Timer &)result);
58413   return jresult;
58414 }
58415
58416
58417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58418   void * jresult ;
58419   Dali::Timer *arg1 = 0 ;
58420   Dali::Timer *result = 0 ;
58421
58422   arg1 = (Dali::Timer *)jarg1;
58423   if (!arg1) {
58424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58425     return 0;
58426   }
58427   {
58428     try {
58429       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*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 = (void *)result;
58450   return jresult;
58451 }
58452
58453
58454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58455   void * jresult ;
58456   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58457   Dali::Timer *arg2 = 0 ;
58458   Dali::Timer *result = 0 ;
58459
58460   arg1 = (Dali::Timer *)jarg1;
58461   arg2 = (Dali::Timer *)jarg2;
58462   if (!arg2) {
58463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58464     return 0;
58465   }
58466   {
58467     try {
58468       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58469     } catch (std::out_of_range& e) {
58470       {
58471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58472       };
58473     } catch (std::exception& e) {
58474       {
58475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58476       };
58477     } catch (Dali::DaliException e) {
58478       {
58479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58480       };
58481     } catch (...) {
58482       {
58483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58484       };
58485     }
58486   }
58487
58488   jresult = (void *)result;
58489   return jresult;
58490 }
58491
58492
58493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58494   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58495
58496   arg1 = (Dali::Timer *)jarg1;
58497   {
58498     try {
58499       delete arg1;
58500     } catch (std::out_of_range& e) {
58501       {
58502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58503       };
58504     } catch (std::exception& e) {
58505       {
58506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58507       };
58508     } catch (Dali::DaliException e) {
58509       {
58510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58511       };
58512     } catch (...) {
58513       {
58514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58515       };
58516     }
58517   }
58518
58519 }
58520
58521
58522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58523   void * jresult ;
58524   Dali::BaseHandle arg1 ;
58525   Dali::BaseHandle *argp1 ;
58526   Dali::Timer result;
58527
58528   argp1 = (Dali::BaseHandle *)jarg1;
58529   if (!argp1) {
58530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58531     return 0;
58532   }
58533   arg1 = *argp1;
58534   {
58535     try {
58536       result = Dali::Timer::DownCast(arg1);
58537     } catch (std::out_of_range& e) {
58538       {
58539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58540       };
58541     } catch (std::exception& e) {
58542       {
58543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58544       };
58545     } catch (Dali::DaliException e) {
58546       {
58547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58548       };
58549     } catch (...) {
58550       {
58551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58552       };
58553     }
58554   }
58555
58556   jresult = new Dali::Timer((const Dali::Timer &)result);
58557   return jresult;
58558 }
58559
58560
58561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58562   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58563
58564   arg1 = (Dali::Timer *)jarg1;
58565   {
58566     try {
58567       (arg1)->Start();
58568     } catch (std::out_of_range& e) {
58569       {
58570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58571       };
58572     } catch (std::exception& e) {
58573       {
58574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58575       };
58576     } catch (Dali::DaliException e) {
58577       {
58578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58579       };
58580     } catch (...) {
58581       {
58582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58583       };
58584     }
58585   }
58586
58587 }
58588
58589
58590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58591   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58592
58593   arg1 = (Dali::Timer *)jarg1;
58594   {
58595     try {
58596       (arg1)->Stop();
58597     } catch (std::out_of_range& e) {
58598       {
58599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58600       };
58601     } catch (std::exception& e) {
58602       {
58603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58604       };
58605     } catch (Dali::DaliException e) {
58606       {
58607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58608       };
58609     } catch (...) {
58610       {
58611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58612       };
58613     }
58614   }
58615
58616 }
58617
58618
58619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58620   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58621   unsigned int arg2 ;
58622
58623   arg1 = (Dali::Timer *)jarg1;
58624   arg2 = (unsigned int)jarg2;
58625   {
58626     try {
58627       (arg1)->SetInterval(arg2);
58628     } catch (std::out_of_range& e) {
58629       {
58630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58631       };
58632     } catch (std::exception& e) {
58633       {
58634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58635       };
58636     } catch (Dali::DaliException e) {
58637       {
58638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58639       };
58640     } catch (...) {
58641       {
58642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58643       };
58644     }
58645   }
58646
58647 }
58648
58649
58650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58651   unsigned int jresult ;
58652   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58653   unsigned int result;
58654
58655   arg1 = (Dali::Timer *)jarg1;
58656   {
58657     try {
58658       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58659     } catch (std::out_of_range& e) {
58660       {
58661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58662       };
58663     } catch (std::exception& e) {
58664       {
58665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58666       };
58667     } catch (Dali::DaliException e) {
58668       {
58669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58670       };
58671     } catch (...) {
58672       {
58673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58674       };
58675     }
58676   }
58677
58678   jresult = result;
58679   return jresult;
58680 }
58681
58682
58683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58684   unsigned int jresult ;
58685   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58686   bool result;
58687
58688   arg1 = (Dali::Timer *)jarg1;
58689   {
58690     try {
58691       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58692     } catch (std::out_of_range& e) {
58693       {
58694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58695       };
58696     } catch (std::exception& e) {
58697       {
58698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58699       };
58700     } catch (Dali::DaliException e) {
58701       {
58702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58703       };
58704     } catch (...) {
58705       {
58706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58707       };
58708     }
58709   }
58710
58711   jresult = result;
58712   return jresult;
58713 }
58714
58715
58716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58717   void * jresult ;
58718   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58719   Dali::Timer::TimerSignalType *result = 0 ;
58720
58721   arg1 = (Dali::Timer *)jarg1;
58722   {
58723     try {
58724       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58725     } catch (std::out_of_range& e) {
58726       {
58727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58728       };
58729     } catch (std::exception& e) {
58730       {
58731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58732       };
58733     } catch (Dali::DaliException e) {
58734       {
58735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58736       };
58737     } catch (...) {
58738       {
58739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58740       };
58741     }
58742   }
58743
58744   jresult = (void *)result;
58745   return jresult;
58746 }
58747
58748
58749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
58750   void * jresult ;
58751   Dali::DragAndDropDetector *result = 0 ;
58752
58753   {
58754     try {
58755       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
58756     } catch (std::out_of_range& e) {
58757       {
58758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58759       };
58760     } catch (std::exception& e) {
58761       {
58762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58763       };
58764     } catch (Dali::DaliException e) {
58765       {
58766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58767       };
58768     } catch (...) {
58769       {
58770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58771       };
58772     }
58773   }
58774
58775   jresult = (void *)result;
58776   return jresult;
58777 }
58778
58779
58780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
58781   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58782
58783   arg1 = (Dali::DragAndDropDetector *)jarg1;
58784   {
58785     try {
58786       delete arg1;
58787     } catch (std::out_of_range& e) {
58788       {
58789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58790       };
58791     } catch (std::exception& e) {
58792       {
58793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58794       };
58795     } catch (Dali::DaliException e) {
58796       {
58797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58798       };
58799     } catch (...) {
58800       {
58801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58802       };
58803     }
58804   }
58805
58806 }
58807
58808
58809 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
58810   char * jresult ;
58811   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58812   std::string *result = 0 ;
58813
58814   arg1 = (Dali::DragAndDropDetector *)jarg1;
58815   {
58816     try {
58817       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
58818     } catch (std::out_of_range& e) {
58819       {
58820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58821       };
58822     } catch (std::exception& e) {
58823       {
58824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58825       };
58826     } catch (Dali::DaliException e) {
58827       {
58828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58829       };
58830     } catch (...) {
58831       {
58832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58833       };
58834     }
58835   }
58836
58837   jresult = SWIG_csharp_string_callback(result->c_str());
58838   return jresult;
58839 }
58840
58841
58842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
58843   void * jresult ;
58844   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58845   Dali::Vector2 result;
58846
58847   arg1 = (Dali::DragAndDropDetector *)jarg1;
58848   {
58849     try {
58850       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
58851     } catch (std::out_of_range& e) {
58852       {
58853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58854       };
58855     } catch (std::exception& e) {
58856       {
58857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58858       };
58859     } catch (Dali::DaliException e) {
58860       {
58861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58862       };
58863     } catch (...) {
58864       {
58865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58866       };
58867     }
58868   }
58869
58870   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
58871   return jresult;
58872 }
58873
58874
58875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
58876   void * jresult ;
58877   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58878   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58879
58880   arg1 = (Dali::DragAndDropDetector *)jarg1;
58881   {
58882     try {
58883       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
58884     } catch (std::out_of_range& e) {
58885       {
58886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58887       };
58888     } catch (std::exception& e) {
58889       {
58890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58891       };
58892     } catch (Dali::DaliException e) {
58893       {
58894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58895       };
58896     } catch (...) {
58897       {
58898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58899       };
58900     }
58901   }
58902
58903   jresult = (void *)result;
58904   return jresult;
58905 }
58906
58907
58908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
58909   void * jresult ;
58910   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58911   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58912
58913   arg1 = (Dali::DragAndDropDetector *)jarg1;
58914   {
58915     try {
58916       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
58917     } catch (std::out_of_range& e) {
58918       {
58919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58920       };
58921     } catch (std::exception& e) {
58922       {
58923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58924       };
58925     } catch (Dali::DaliException e) {
58926       {
58927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58928       };
58929     } catch (...) {
58930       {
58931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58932       };
58933     }
58934   }
58935
58936   jresult = (void *)result;
58937   return jresult;
58938 }
58939
58940
58941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
58942   void * jresult ;
58943   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58944   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58945
58946   arg1 = (Dali::DragAndDropDetector *)jarg1;
58947   {
58948     try {
58949       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
58950     } catch (std::out_of_range& e) {
58951       {
58952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58953       };
58954     } catch (std::exception& e) {
58955       {
58956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58957       };
58958     } catch (Dali::DaliException e) {
58959       {
58960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58961       };
58962     } catch (...) {
58963       {
58964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58965       };
58966     }
58967   }
58968
58969   jresult = (void *)result;
58970   return jresult;
58971 }
58972
58973
58974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
58975   void * jresult ;
58976   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58977   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58978
58979   arg1 = (Dali::DragAndDropDetector *)jarg1;
58980   {
58981     try {
58982       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
58983     } catch (std::out_of_range& e) {
58984       {
58985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58986       };
58987     } catch (std::exception& e) {
58988       {
58989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58990       };
58991     } catch (Dali::DaliException e) {
58992       {
58993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58994       };
58995     } catch (...) {
58996       {
58997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58998       };
58999     }
59000   }
59001
59002   jresult = (void *)result;
59003   return jresult;
59004 }
59005
59006
59007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
59008   void * jresult ;
59009   Dali::ApplicationExtensions *result = 0 ;
59010
59011   {
59012     try {
59013       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
59014     } catch (std::out_of_range& e) {
59015       {
59016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59017       };
59018     } catch (std::exception& e) {
59019       {
59020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59021       };
59022     } catch (Dali::DaliException e) {
59023       {
59024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59025       };
59026     } catch (...) {
59027       {
59028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59029       };
59030     }
59031   }
59032
59033   jresult = (void *)result;
59034   return jresult;
59035 }
59036
59037
59038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
59039   void * jresult ;
59040   Dali::Application *arg1 = (Dali::Application *) 0 ;
59041   Dali::ApplicationExtensions *result = 0 ;
59042
59043   arg1 = (Dali::Application *)jarg1;
59044   {
59045     try {
59046       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
59047     } catch (std::out_of_range& e) {
59048       {
59049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59050       };
59051     } catch (std::exception& e) {
59052       {
59053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59054       };
59055     } catch (Dali::DaliException e) {
59056       {
59057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59058       };
59059     } catch (...) {
59060       {
59061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59062       };
59063     }
59064   }
59065
59066   jresult = (void *)result;
59067   return jresult;
59068 }
59069
59070
59071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
59072   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59073
59074   arg1 = (Dali::ApplicationExtensions *)jarg1;
59075   {
59076     try {
59077       delete arg1;
59078     } catch (std::out_of_range& e) {
59079       {
59080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59081       };
59082     } catch (std::exception& e) {
59083       {
59084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59085       };
59086     } catch (Dali::DaliException e) {
59087       {
59088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59089       };
59090     } catch (...) {
59091       {
59092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59093       };
59094     }
59095   }
59096
59097 }
59098
59099
59100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
59101   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59102
59103   arg1 = (Dali::ApplicationExtensions *)jarg1;
59104   {
59105     try {
59106       (arg1)->Init();
59107     } catch (std::out_of_range& e) {
59108       {
59109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59110       };
59111     } catch (std::exception& e) {
59112       {
59113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59114       };
59115     } catch (Dali::DaliException e) {
59116       {
59117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59118       };
59119     } catch (...) {
59120       {
59121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59122       };
59123     }
59124   }
59125
59126 }
59127
59128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
59129   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59130
59131   arg1 = (Dali::ApplicationExtensions *)jarg1;
59132   {
59133     try {
59134       (arg1)->Start();
59135     } catch (std::out_of_range& e) {
59136       {
59137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59138       };
59139     } catch (std::exception& e) {
59140       {
59141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59142       };
59143     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }
59144   }
59145 }
59146
59147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
59148   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59149
59150   arg1 = (Dali::ApplicationExtensions *)jarg1;
59151   {
59152     try {
59153       (arg1)->Terminate();
59154     } catch (std::out_of_range& e) {
59155       {
59156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59157       };
59158     } catch (std::exception& e) {
59159       {
59160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59161       };
59162     } catch (Dali::DaliException e) {
59163       {
59164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59165       };
59166     } catch (...) {
59167       {
59168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59169       };
59170     }
59171   }
59172
59173 }
59174
59175
59176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
59177   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59178
59179   arg1 = (Dali::ApplicationExtensions *)jarg1;
59180   {
59181     try {
59182       (arg1)->Pause();
59183     } catch (std::out_of_range& e) {
59184       {
59185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59186       };
59187     } catch (std::exception& e) {
59188       {
59189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59190       };
59191     } catch (Dali::DaliException e) {
59192       {
59193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59194       };
59195     } catch (...) {
59196       {
59197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59198       };
59199     }
59200   }
59201
59202 }
59203
59204
59205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
59206   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59207
59208   arg1 = (Dali::ApplicationExtensions *)jarg1;
59209   {
59210     try {
59211       (arg1)->Resume();
59212     } catch (std::out_of_range& e) {
59213       {
59214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59215       };
59216     } catch (std::exception& e) {
59217       {
59218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59219       };
59220     } catch (Dali::DaliException e) {
59221       {
59222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59223       };
59224     } catch (...) {
59225       {
59226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59227       };
59228     }
59229   }
59230
59231 }
59232
59233
59234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
59235   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59236
59237   arg1 = (Dali::ApplicationExtensions *)jarg1;
59238   {
59239     try {
59240       (arg1)->LanguageChange();
59241     } catch (std::out_of_range& e) {
59242       {
59243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59244       };
59245     } catch (std::exception& e) {
59246       {
59247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59248       };
59249     } catch (Dali::DaliException e) {
59250       {
59251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59252       };
59253     } catch (...) {
59254       {
59255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59256       };
59257     }
59258   }
59259
59260 }
59261
59262
59263
59264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
59265   unsigned int jresult ;
59266   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59267   bool result;
59268
59269   arg1 = (Dali::Signal< bool () > *)jarg1;
59270   {
59271     try {
59272       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
59273     } catch (std::out_of_range& e) {
59274       {
59275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59276       };
59277     } catch (std::exception& e) {
59278       {
59279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59280       };
59281     } catch (Dali::DaliException e) {
59282       {
59283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59284       };
59285     } catch (...) {
59286       {
59287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59288       };
59289     }
59290   }
59291
59292   jresult = result;
59293   return jresult;
59294 }
59295
59296
59297 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
59298   unsigned long jresult ;
59299   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59300   std::size_t result;
59301
59302   arg1 = (Dali::Signal< bool () > *)jarg1;
59303   {
59304     try {
59305       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
59306     } catch (std::out_of_range& e) {
59307       {
59308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59309       };
59310     } catch (std::exception& e) {
59311       {
59312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59313       };
59314     } catch (Dali::DaliException e) {
59315       {
59316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59317       };
59318     } catch (...) {
59319       {
59320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59321       };
59322     }
59323   }
59324
59325   jresult = (unsigned long)result;
59326   return jresult;
59327 }
59328
59329
59330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
59331   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59332   bool (*arg2)() = (bool (*)()) 0 ;
59333
59334   arg1 = (Dali::Signal< bool () > *)jarg1;
59335   arg2 = (bool (*)())jarg2;
59336   {
59337     try {
59338       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
59339     } catch (std::out_of_range& e) {
59340       {
59341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59342       };
59343     } catch (std::exception& e) {
59344       {
59345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59346       };
59347     } catch (Dali::DaliException e) {
59348       {
59349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59350       };
59351     } catch (...) {
59352       {
59353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59354       };
59355     }
59356   }
59357
59358 }
59359
59360
59361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
59362   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59363   bool (*arg2)() = (bool (*)()) 0 ;
59364
59365   arg1 = (Dali::Signal< bool () > *)jarg1;
59366   arg2 = (bool (*)())jarg2;
59367   {
59368     try {
59369       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
59370     } catch (std::out_of_range& e) {
59371       {
59372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59373       };
59374     } catch (std::exception& e) {
59375       {
59376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59377       };
59378     } catch (Dali::DaliException e) {
59379       {
59380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59381       };
59382     } catch (...) {
59383       {
59384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59385       };
59386     }
59387   }
59388
59389 }
59390
59391
59392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
59393   unsigned int jresult ;
59394   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59395   bool result;
59396
59397   arg1 = (Dali::Signal< bool () > *)jarg1;
59398   {
59399     try {
59400       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
59401     } catch (std::out_of_range& e) {
59402       {
59403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59404       };
59405     } catch (std::exception& e) {
59406       {
59407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59408       };
59409     } catch (Dali::DaliException e) {
59410       {
59411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59412       };
59413     } catch (...) {
59414       {
59415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59416       };
59417     }
59418   }
59419
59420   jresult = result;
59421   return jresult;
59422 }
59423
59424
59425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59426   void * jresult ;
59427   Dali::Signal< bool () > *result = 0 ;
59428
59429   {
59430     try {
59431       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59432     } catch (std::out_of_range& e) {
59433       {
59434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59435       };
59436     } catch (std::exception& e) {
59437       {
59438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59439       };
59440     } catch (Dali::DaliException e) {
59441       {
59442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59443       };
59444     } catch (...) {
59445       {
59446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59447       };
59448     }
59449   }
59450
59451   jresult = (void *)result;
59452   return jresult;
59453 }
59454
59455
59456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59457   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59458
59459   arg1 = (Dali::Signal< bool () > *)jarg1;
59460   {
59461     try {
59462       delete arg1;
59463     } catch (std::out_of_range& e) {
59464       {
59465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59466       };
59467     } catch (std::exception& e) {
59468       {
59469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59470       };
59471     } catch (Dali::DaliException e) {
59472       {
59473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59474       };
59475     } catch (...) {
59476       {
59477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59478       };
59479     }
59480   }
59481
59482 }
59483
59484
59485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59486   int jresult ;
59487   int result;
59488
59489   {
59490     try {
59491       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59492     } catch (std::out_of_range& e) {
59493       {
59494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59495       };
59496     } catch (std::exception& e) {
59497       {
59498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59499       };
59500     } catch (Dali::DaliException e) {
59501       {
59502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59503       };
59504     } catch (...) {
59505       {
59506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59507       };
59508     }
59509   }
59510
59511   jresult = (int)result;
59512   return jresult;
59513 }
59514
59515
59516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59517   int jresult ;
59518   int result;
59519
59520   {
59521     try {
59522       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59523     } catch (std::out_of_range& e) {
59524       {
59525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59526       };
59527     } catch (std::exception& e) {
59528       {
59529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59530       };
59531     } catch (Dali::DaliException e) {
59532       {
59533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59534       };
59535     } catch (...) {
59536       {
59537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59538       };
59539     }
59540   }
59541
59542   jresult = (int)result;
59543   return jresult;
59544 }
59545
59546
59547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59548   int jresult ;
59549   int result;
59550
59551   {
59552     try {
59553       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59554     } catch (std::out_of_range& e) {
59555       {
59556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59557       };
59558     } catch (std::exception& e) {
59559       {
59560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59561       };
59562     } catch (Dali::DaliException e) {
59563       {
59564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59565       };
59566     } catch (...) {
59567       {
59568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59569       };
59570     }
59571   }
59572
59573   jresult = (int)result;
59574   return jresult;
59575 }
59576
59577
59578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59579   int jresult ;
59580   int result;
59581
59582   {
59583     try {
59584       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59585     } catch (std::out_of_range& e) {
59586       {
59587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59588       };
59589     } catch (std::exception& e) {
59590       {
59591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59592       };
59593     } catch (Dali::DaliException e) {
59594       {
59595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59596       };
59597     } catch (...) {
59598       {
59599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59600       };
59601     }
59602   }
59603
59604   jresult = (int)result;
59605   return jresult;
59606 }
59607
59608
59609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59610   int jresult ;
59611   int result;
59612
59613   {
59614     try {
59615       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59616     } catch (std::out_of_range& e) {
59617       {
59618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59619       };
59620     } catch (std::exception& e) {
59621       {
59622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59623       };
59624     } catch (Dali::DaliException e) {
59625       {
59626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59627       };
59628     } catch (...) {
59629       {
59630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59631       };
59632     }
59633   }
59634
59635   jresult = (int)result;
59636   return jresult;
59637 }
59638
59639
59640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59641   int jresult ;
59642   int result;
59643
59644   {
59645     try {
59646       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59647     } catch (std::out_of_range& e) {
59648       {
59649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59650       };
59651     } catch (std::exception& e) {
59652       {
59653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59654       };
59655     } catch (Dali::DaliException e) {
59656       {
59657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59658       };
59659     } catch (...) {
59660       {
59661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59662       };
59663     }
59664   }
59665
59666   jresult = (int)result;
59667   return jresult;
59668 }
59669
59670
59671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59672   int jresult ;
59673   int result;
59674
59675   {
59676     try {
59677       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59678     } catch (std::out_of_range& e) {
59679       {
59680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59681       };
59682     } catch (std::exception& e) {
59683       {
59684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59685       };
59686     } catch (Dali::DaliException e) {
59687       {
59688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59689       };
59690     } catch (...) {
59691       {
59692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59693       };
59694     }
59695   }
59696
59697   jresult = (int)result;
59698   return jresult;
59699 }
59700
59701
59702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59703   int jresult ;
59704   int result;
59705
59706   {
59707     try {
59708       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59709     } catch (std::out_of_range& e) {
59710       {
59711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59712       };
59713     } catch (std::exception& e) {
59714       {
59715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59716       };
59717     } catch (Dali::DaliException e) {
59718       {
59719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59720       };
59721     } catch (...) {
59722       {
59723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59724       };
59725     }
59726   }
59727
59728   jresult = (int)result;
59729   return jresult;
59730 }
59731
59732
59733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59734   int jresult ;
59735   int result;
59736
59737   {
59738     try {
59739       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59740     } catch (std::out_of_range& e) {
59741       {
59742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59743       };
59744     } catch (std::exception& e) {
59745       {
59746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59747       };
59748     } catch (Dali::DaliException e) {
59749       {
59750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59751       };
59752     } catch (...) {
59753       {
59754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59755       };
59756     }
59757   }
59758
59759   jresult = (int)result;
59760   return jresult;
59761 }
59762
59763
59764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59765   int jresult ;
59766   int result;
59767
59768   {
59769     try {
59770       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59771     } catch (std::out_of_range& e) {
59772       {
59773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59774       };
59775     } catch (std::exception& e) {
59776       {
59777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59778       };
59779     } catch (Dali::DaliException e) {
59780       {
59781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59782       };
59783     } catch (...) {
59784       {
59785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59786       };
59787     }
59788   }
59789
59790   jresult = (int)result;
59791   return jresult;
59792 }
59793
59794
59795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59796   int jresult ;
59797   int result;
59798
59799   {
59800     try {
59801       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59802     } catch (std::out_of_range& e) {
59803       {
59804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59805       };
59806     } catch (std::exception& e) {
59807       {
59808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59809       };
59810     } catch (Dali::DaliException e) {
59811       {
59812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59813       };
59814     } catch (...) {
59815       {
59816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59817       };
59818     }
59819   }
59820
59821   jresult = (int)result;
59822   return jresult;
59823 }
59824
59825
59826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59827   int jresult ;
59828   int result;
59829
59830   {
59831     try {
59832       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59833     } catch (std::out_of_range& e) {
59834       {
59835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59836       };
59837     } catch (std::exception& e) {
59838       {
59839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59840       };
59841     } catch (Dali::DaliException e) {
59842       {
59843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59844       };
59845     } catch (...) {
59846       {
59847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59848       };
59849     }
59850   }
59851
59852   jresult = (int)result;
59853   return jresult;
59854 }
59855
59856
59857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59858   int jresult ;
59859   int result;
59860
59861   {
59862     try {
59863       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59864     } catch (std::out_of_range& e) {
59865       {
59866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59867       };
59868     } catch (std::exception& e) {
59869       {
59870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59871       };
59872     } catch (Dali::DaliException e) {
59873       {
59874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59875       };
59876     } catch (...) {
59877       {
59878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59879       };
59880     }
59881   }
59882
59883   jresult = (int)result;
59884   return jresult;
59885 }
59886
59887
59888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59889   int jresult ;
59890   int result;
59891
59892   {
59893     try {
59894       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59895     } catch (std::out_of_range& e) {
59896       {
59897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59898       };
59899     } catch (std::exception& e) {
59900       {
59901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59902       };
59903     } catch (Dali::DaliException e) {
59904       {
59905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59906       };
59907     } catch (...) {
59908       {
59909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59910       };
59911     }
59912   }
59913
59914   jresult = (int)result;
59915   return jresult;
59916 }
59917
59918
59919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59920   int jresult ;
59921   int result;
59922
59923   {
59924     try {
59925       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59926     } catch (std::out_of_range& e) {
59927       {
59928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59929       };
59930     } catch (std::exception& e) {
59931       {
59932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59933       };
59934     } catch (Dali::DaliException e) {
59935       {
59936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59937       };
59938     } catch (...) {
59939       {
59940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59941       };
59942     }
59943   }
59944
59945   jresult = (int)result;
59946   return jresult;
59947 }
59948
59949
59950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59951   int jresult ;
59952   int result;
59953
59954   {
59955     try {
59956       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59957     } catch (std::out_of_range& e) {
59958       {
59959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59960       };
59961     } catch (std::exception& e) {
59962       {
59963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59964       };
59965     } catch (Dali::DaliException e) {
59966       {
59967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59968       };
59969     } catch (...) {
59970       {
59971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59972       };
59973     }
59974   }
59975
59976   jresult = (int)result;
59977   return jresult;
59978 }
59979
59980
59981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59982   int jresult ;
59983   int result;
59984
59985   {
59986     try {
59987       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59988     } catch (std::out_of_range& e) {
59989       {
59990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59991       };
59992     } catch (std::exception& e) {
59993       {
59994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59995       };
59996     } catch (Dali::DaliException e) {
59997       {
59998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59999       };
60000     } catch (...) {
60001       {
60002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60003       };
60004     }
60005   }
60006
60007   jresult = (int)result;
60008   return jresult;
60009 }
60010
60011
60012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
60013   int jresult ;
60014   int result;
60015
60016   {
60017     try {
60018       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
60019     } catch (std::out_of_range& e) {
60020       {
60021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60022       };
60023     } catch (std::exception& e) {
60024       {
60025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60026       };
60027     } catch (Dali::DaliException e) {
60028       {
60029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60030       };
60031     } catch (...) {
60032       {
60033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60034       };
60035     }
60036   }
60037
60038   jresult = (int)result;
60039   return jresult;
60040 }
60041
60042
60043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
60044   int jresult ;
60045   int result;
60046
60047   {
60048     try {
60049       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
60050     } catch (std::out_of_range& e) {
60051       {
60052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60053       };
60054     } catch (std::exception& e) {
60055       {
60056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60057       };
60058     } catch (Dali::DaliException e) {
60059       {
60060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60061       };
60062     } catch (...) {
60063       {
60064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60065       };
60066     }
60067   }
60068
60069   jresult = (int)result;
60070   return jresult;
60071 }
60072
60073
60074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
60075   int jresult ;
60076   int result;
60077
60078   {
60079     try {
60080       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
60081     } catch (std::out_of_range& e) {
60082       {
60083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60084       };
60085     } catch (std::exception& e) {
60086       {
60087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60088       };
60089     } catch (Dali::DaliException e) {
60090       {
60091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60092       };
60093     } catch (...) {
60094       {
60095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60096       };
60097     }
60098   }
60099
60100   jresult = (int)result;
60101   return jresult;
60102 }
60103
60104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
60105   int jresult ;
60106   int result;
60107
60108   {
60109     try {
60110       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
60111     } catch (std::out_of_range& e) {
60112       {
60113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60114       };
60115     } catch (std::exception& e) {
60116       {
60117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60118       };
60119     } catch (Dali::DaliException e) {
60120       {
60121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60122       };
60123     } catch (...) {
60124       {
60125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60126       };
60127     }
60128   }
60129
60130   jresult = (int)result;
60131   return jresult;
60132 }
60133
60134
60135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
60136   int jresult ;
60137   int result;
60138   {
60139     try
60140     {
60141       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
60142     } catch (std::out_of_range& e) {
60143       {
60144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60145       };
60146     } catch (std::exception& e) {
60147       {
60148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60149       };
60150     } catch (Dali::DaliException e) {
60151       {
60152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60153       };
60154     } catch (...) {
60155       {
60156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60157       };
60158     }
60159   }
60160
60161   jresult = (int)result;
60162   return jresult;
60163 }
60164
60165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
60166   int jresult ;
60167   int result;
60168   {
60169     try
60170     {
60171       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
60172     } catch (std::out_of_range& e) {
60173       {
60174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60175       };
60176     } catch (std::exception& e) {
60177       {
60178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60179       };
60180     } catch (Dali::DaliException e) {
60181       {
60182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60183       };
60184     } catch (...) {
60185       {
60186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60187       };
60188     }
60189   }
60190
60191   jresult = (int)result;
60192   return jresult;
60193 }
60194
60195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
60196   int jresult ;
60197   int result;
60198   {
60199     try
60200     {
60201       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
60202     } catch (std::out_of_range& e) {
60203       {
60204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60205       };
60206     } catch (std::exception& e) {
60207       {
60208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60209       };
60210     } catch (Dali::DaliException e) {
60211       {
60212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60213       };
60214     } catch (...) {
60215       {
60216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60217       };
60218     }
60219   }
60220
60221   jresult = (int)result;
60222   return jresult;
60223 }
60224
60225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
60226   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
60227 }
60228
60229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
60230   int jresult ;
60231   int result;
60232   {
60233     try
60234     {
60235       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
60236     } catch (std::out_of_range& e) {
60237       {
60238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60239       };
60240     } catch (std::exception& e) {
60241       {
60242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60243       };
60244     } catch (Dali::DaliException e) {
60245       {
60246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60247       };
60248     } catch (...) {
60249       {
60250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60251       };
60252     }
60253   }
60254
60255   jresult = (int)result;
60256   return jresult;
60257 }
60258
60259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
60260   int jresult ;
60261   int result;
60262   {
60263     try
60264     {
60265       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
60266     } catch (std::out_of_range& e) {
60267       {
60268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60269       };
60270     } catch (std::exception& e) {
60271       {
60272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60273       };
60274     } catch (Dali::DaliException e) {
60275       {
60276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60277       };
60278     } catch (...) {
60279       {
60280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60281       };
60282     }
60283   }
60284
60285   jresult = (int)result;
60286   return jresult;
60287 }
60288
60289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
60290   int jresult ;
60291   int result;
60292
60293   {
60294     try {
60295       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
60296     } catch (std::out_of_range& e) {
60297       {
60298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60299       };
60300     } catch (std::exception& e) {
60301       {
60302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60303       };
60304     } catch (Dali::DaliException e) {
60305       {
60306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60307       };
60308     } catch (...) {
60309       {
60310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60311       };
60312     }
60313   }
60314
60315   jresult = (int)result;
60316   return jresult;
60317 }
60318
60319
60320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
60321   int jresult ;
60322   int result;
60323
60324   {
60325     try {
60326       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
60327     } catch (std::out_of_range& e) {
60328       {
60329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60330       };
60331     } catch (std::exception& e) {
60332       {
60333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60334       };
60335     } catch (Dali::DaliException e) {
60336       {
60337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60338       };
60339     } catch (...) {
60340       {
60341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60342       };
60343     }
60344   }
60345
60346   jresult = (int)result;
60347   return jresult;
60348 }
60349
60350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
60351   int jresult ;
60352   int result;
60353   {
60354     try
60355     {
60356       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
60357     } catch (std::out_of_range& e) {
60358       {
60359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60360       };
60361     } catch (std::exception& e) {
60362       {
60363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60364       };
60365     } catch (...) {
60366       {
60367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60368       };
60369     }
60370   }
60371   jresult = (int)result;
60372   return jresult;
60373 }
60374
60375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60376   int jresult ;
60377   int result;
60378   {
60379     try
60380     {
60381       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
60382     } catch (std::out_of_range& e) {
60383       {
60384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60385       };
60386     } catch (std::exception& e) {
60387       {
60388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60389       };
60390     } catch (...) {
60391       {
60392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60393       };
60394     }
60395   }
60396   jresult = (int)result;
60397   return jresult;
60398 }
60399
60400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60401   int jresult ;
60402   int result;
60403   {
60404     try
60405     {
60406       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
60407     } catch (std::out_of_range& e) {
60408       {
60409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60410       };
60411     } catch (std::exception& e) {
60412       {
60413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60414       };
60415     } catch (...) {
60416       {
60417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60418       };
60419     }
60420   }
60421   jresult = (int)result;
60422   return jresult;
60423 }
60424
60425
60426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60427   int jresult ;
60428   int result;
60429   {
60430     try
60431     {
60432       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60433     } catch (std::out_of_range& e) {
60434       {
60435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60436       };
60437     } catch (std::exception& e) {
60438       {
60439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60440       };
60441     } catch (...) {
60442       {
60443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60444       };
60445     }
60446   }
60447   jresult = (int)result;
60448   return jresult;
60449 }
60450
60451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60452   int jresult ;
60453   int result;
60454   {
60455     try
60456     {
60457       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60458     } catch (std::out_of_range& e) {
60459       {
60460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60461       };
60462     } catch (std::exception& e) {
60463       {
60464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60465       };
60466     } catch (...) {
60467       {
60468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60469       };
60470     }
60471   }
60472   jresult = (int)result;
60473   return jresult;
60474 }
60475
60476
60477
60478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60479   int jresult ;
60480   int result;
60481
60482   {
60483     try {
60484       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60485     } catch (std::out_of_range& e) {
60486       {
60487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60488       };
60489     } catch (std::exception& e) {
60490       {
60491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60492       };
60493     } catch (Dali::DaliException e) {
60494       {
60495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60496       };
60497     } catch (...) {
60498       {
60499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60500       };
60501     }
60502   }
60503
60504   jresult = (int)result;
60505   return jresult;
60506 }
60507
60508
60509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60510   int jresult ;
60511   int result;
60512
60513   {
60514     try {
60515       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60516     } catch (std::out_of_range& e) {
60517       {
60518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60519       };
60520     } catch (std::exception& e) {
60521       {
60522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60523       };
60524     } catch (Dali::DaliException e) {
60525       {
60526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60527       };
60528     } catch (...) {
60529       {
60530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60531       };
60532     }
60533   }
60534
60535   jresult = (int)result;
60536   return jresult;
60537 }
60538
60539
60540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60541   int jresult ;
60542   int result;
60543
60544   {
60545     try {
60546       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60547     } catch (std::out_of_range& e) {
60548       {
60549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60550       };
60551     } catch (std::exception& e) {
60552       {
60553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60554       };
60555     } catch (Dali::DaliException e) {
60556       {
60557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60558       };
60559     } catch (...) {
60560       {
60561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60562       };
60563     }
60564   }
60565
60566   jresult = (int)result;
60567   return jresult;
60568 }
60569
60570
60571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60572   int jresult ;
60573   int result;
60574
60575   {
60576     try {
60577       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60578     } catch (std::out_of_range& e) {
60579       {
60580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60581       };
60582     } catch (std::exception& e) {
60583       {
60584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60585       };
60586     } catch (Dali::DaliException e) {
60587       {
60588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60589       };
60590     } catch (...) {
60591       {
60592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60593       };
60594     }
60595   }
60596
60597   jresult = (int)result;
60598   return jresult;
60599 }
60600
60601
60602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60603   int jresult ;
60604   int result;
60605
60606   {
60607     try {
60608       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60609     } catch (std::out_of_range& e) {
60610       {
60611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60612       };
60613     } catch (std::exception& e) {
60614       {
60615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60616       };
60617     } catch (Dali::DaliException e) {
60618       {
60619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60620       };
60621     } catch (...) {
60622       {
60623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60624       };
60625     }
60626   }
60627
60628   jresult = (int)result;
60629   return jresult;
60630 }
60631
60632
60633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60634   int jresult ;
60635   int result;
60636
60637   {
60638     try {
60639       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60640     } catch (std::out_of_range& e) {
60641       {
60642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60643       };
60644     } catch (std::exception& e) {
60645       {
60646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60647       };
60648     } catch (Dali::DaliException e) {
60649       {
60650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60651       };
60652     } catch (...) {
60653       {
60654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60655       };
60656     }
60657   }
60658
60659   jresult = (int)result;
60660   return jresult;
60661 }
60662
60663
60664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60665   int jresult ;
60666   int result;
60667
60668   {
60669     try {
60670       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60671     } catch (std::out_of_range& e) {
60672       {
60673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60674       };
60675     } catch (std::exception& e) {
60676       {
60677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60678       };
60679     } catch (Dali::DaliException e) {
60680       {
60681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60682       };
60683     } catch (...) {
60684       {
60685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60686       };
60687     }
60688   }
60689
60690   jresult = (int)result;
60691   return jresult;
60692 }
60693
60694 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60695   int jresult ;
60696   int result;
60697
60698   {
60699     try {
60700       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60701     } catch (std::out_of_range& e) {
60702       {
60703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60704       };
60705     } catch (std::exception& e) {
60706       {
60707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60708       };
60709     } catch (...) {
60710       {
60711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60712       };
60713     }
60714   }
60715   jresult = (int)result;
60716   return jresult;
60717 }
60718
60719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60720   int jresult ;
60721   int result;
60722
60723   {
60724     try {
60725       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60726     } catch (std::out_of_range& e) {
60727       {
60728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60729       };
60730     } catch (std::exception& e) {
60731       {
60732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60733       };
60734     } catch (Dali::DaliException e) {
60735       {
60736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60737       };
60738     } catch (...) {
60739       {
60740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60741       };
60742     }
60743   }
60744
60745   jresult = (int)result;
60746   return jresult;
60747 }
60748
60749
60750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60751   int jresult ;
60752   int result;
60753
60754   {
60755     try {
60756       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60757     } catch (std::out_of_range& e) {
60758       {
60759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60760       };
60761     } catch (std::exception& e) {
60762       {
60763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60764       };
60765     } catch (Dali::DaliException e) {
60766       {
60767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60768       };
60769     } catch (...) {
60770       {
60771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60772       };
60773     }
60774   }
60775
60776   jresult = (int)result;
60777   return jresult;
60778 }
60779
60780
60781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60782   int jresult ;
60783   int result;
60784
60785   {
60786     try {
60787       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60788     } catch (std::out_of_range& e) {
60789       {
60790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60791       };
60792     } catch (std::exception& e) {
60793       {
60794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60795       };
60796     } catch (Dali::DaliException e) {
60797       {
60798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60799       };
60800     } catch (...) {
60801       {
60802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60803       };
60804     }
60805   }
60806
60807   jresult = (int)result;
60808   return jresult;
60809 }
60810
60811
60812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60813   int jresult ;
60814   int result;
60815
60816   {
60817     try {
60818       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60819     } catch (std::out_of_range& e) {
60820       {
60821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60822       };
60823     } catch (std::exception& e) {
60824       {
60825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60826       };
60827     } catch (Dali::DaliException e) {
60828       {
60829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60830       };
60831     } catch (...) {
60832       {
60833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60834       };
60835     }
60836   }
60837
60838   jresult = (int)result;
60839   return jresult;
60840 }
60841
60842
60843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60844   int jresult ;
60845   int result;
60846
60847   {
60848     try {
60849       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60850     } catch (std::out_of_range& e) {
60851       {
60852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60853       };
60854     } catch (std::exception& e) {
60855       {
60856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60857       };
60858     } catch (Dali::DaliException e) {
60859       {
60860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60861       };
60862     } catch (...) {
60863       {
60864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60865       };
60866     }
60867   }
60868
60869   jresult = (int)result;
60870   return jresult;
60871 }
60872
60873
60874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60875   int jresult ;
60876   int result;
60877
60878   {
60879     try {
60880       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60881     } catch (std::out_of_range& e) {
60882       {
60883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60884       };
60885     } catch (std::exception& e) {
60886       {
60887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60888       };
60889     } catch (Dali::DaliException e) {
60890       {
60891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60892       };
60893     } catch (...) {
60894       {
60895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60896       };
60897     }
60898   }
60899
60900   jresult = (int)result;
60901   return jresult;
60902 }
60903
60904
60905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60906   int jresult ;
60907   int result;
60908
60909   {
60910     try {
60911       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60912     } catch (std::out_of_range& e) {
60913       {
60914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60915       };
60916     } catch (std::exception& e) {
60917       {
60918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60919       };
60920     } catch (Dali::DaliException e) {
60921       {
60922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60923       };
60924     } catch (...) {
60925       {
60926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60927       };
60928     }
60929   }
60930
60931   jresult = (int)result;
60932   return jresult;
60933 }
60934
60935
60936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60937   int jresult ;
60938   int result;
60939
60940   {
60941     try {
60942       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60943     } catch (std::out_of_range& e) {
60944       {
60945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60946       };
60947     } catch (std::exception& e) {
60948       {
60949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60950       };
60951     } catch (Dali::DaliException e) {
60952       {
60953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60954       };
60955     } catch (...) {
60956       {
60957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60958       };
60959     }
60960   }
60961
60962   jresult = (int)result;
60963   return jresult;
60964 }
60965
60966
60967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60968   int jresult ;
60969   int result;
60970
60971   {
60972     try {
60973       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60974     } catch (std::out_of_range& e) {
60975       {
60976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60977       };
60978     } catch (std::exception& e) {
60979       {
60980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60981       };
60982     } catch (Dali::DaliException e) {
60983       {
60984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60985       };
60986     } catch (...) {
60987       {
60988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60989       };
60990     }
60991   }
60992
60993   jresult = (int)result;
60994   return jresult;
60995 }
60996
60997
60998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60999   int jresult ;
61000   int result;
61001
61002   {
61003     try {
61004       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
61005     } catch (std::out_of_range& e) {
61006       {
61007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61008       };
61009     } catch (std::exception& e) {
61010       {
61011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61012       };
61013     } catch (Dali::DaliException e) {
61014       {
61015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61016       };
61017     } catch (...) {
61018       {
61019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61020       };
61021     }
61022   }
61023
61024   jresult = (int)result;
61025   return jresult;
61026 }
61027
61028
61029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
61030   int jresult ;
61031   int result;
61032
61033   {
61034     try {
61035       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
61036     } catch (std::out_of_range& e) {
61037       {
61038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61039       };
61040     } catch (std::exception& e) {
61041       {
61042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61043       };
61044     } catch (Dali::DaliException e) {
61045       {
61046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61047       };
61048     } catch (...) {
61049       {
61050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61051       };
61052     }
61053   }
61054
61055   jresult = (int)result;
61056   return jresult;
61057 }
61058
61059
61060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
61061   int jresult ;
61062   int result;
61063
61064   {
61065     try {
61066       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
61067     } catch (std::out_of_range& e) {
61068       {
61069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61070       };
61071     } catch (std::exception& e) {
61072       {
61073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61074       };
61075     } catch (Dali::DaliException e) {
61076       {
61077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61078       };
61079     } catch (...) {
61080       {
61081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61082       };
61083     }
61084   }
61085
61086   jresult = (int)result;
61087   return jresult;
61088 }
61089
61090
61091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
61092   int jresult ;
61093   int result;
61094
61095   {
61096     try {
61097       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
61098     } catch (std::out_of_range& e) {
61099       {
61100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61101       };
61102     } catch (std::exception& e) {
61103       {
61104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61105       };
61106     } catch (Dali::DaliException e) {
61107       {
61108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61109       };
61110     } catch (...) {
61111       {
61112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61113       };
61114     }
61115   }
61116
61117   jresult = (int)result;
61118   return jresult;
61119 }
61120
61121
61122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
61123   int jresult ;
61124   int result;
61125
61126   {
61127     try {
61128       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
61129     } catch (std::out_of_range& e) {
61130       {
61131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61132       };
61133     } catch (std::exception& e) {
61134       {
61135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61136       };
61137     } catch (Dali::DaliException e) {
61138       {
61139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61140       };
61141     } catch (...) {
61142       {
61143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61144       };
61145     }
61146   }
61147
61148   jresult = (int)result;
61149   return jresult;
61150 }
61151
61152
61153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
61154   int jresult ;
61155   int result;
61156
61157   {
61158     try {
61159       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
61160     } catch (std::out_of_range& e) {
61161       {
61162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61163       };
61164     } catch (std::exception& e) {
61165       {
61166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61167       };
61168     } catch (Dali::DaliException e) {
61169       {
61170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61171       };
61172     } catch (...) {
61173       {
61174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61175       };
61176     }
61177   }
61178
61179   jresult = (int)result;
61180   return jresult;
61181 }
61182
61183
61184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
61185   int jresult ;
61186   int result;
61187
61188   {
61189     try {
61190       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
61191     } catch (std::out_of_range& e) {
61192       {
61193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61194       };
61195     } catch (std::exception& e) {
61196       {
61197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61198       };
61199     } catch (Dali::DaliException e) {
61200       {
61201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61202       };
61203     } catch (...) {
61204       {
61205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61206       };
61207     }
61208   }
61209
61210   jresult = (int)result;
61211   return jresult;
61212 }
61213
61214
61215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
61216   int jresult ;
61217   int result;
61218
61219   {
61220     try {
61221       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
61222     } catch (std::out_of_range& e) {
61223       {
61224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61225       };
61226     } catch (std::exception& e) {
61227       {
61228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61229       };
61230     } catch (Dali::DaliException e) {
61231       {
61232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61233       };
61234     } catch (...) {
61235       {
61236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61237       };
61238     }
61239   }
61240
61241   jresult = (int)result;
61242   return jresult;
61243 }
61244
61245
61246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
61247   int jresult ;
61248   int result;
61249
61250   {
61251     try {
61252       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
61253     } catch (std::out_of_range& e) {
61254       {
61255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61256       };
61257     } catch (std::exception& e) {
61258       {
61259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61260       };
61261     } catch (Dali::DaliException e) {
61262       {
61263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61264       };
61265     } catch (...) {
61266       {
61267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61268       };
61269     }
61270   }
61271
61272   jresult = (int)result;
61273   return jresult;
61274 }
61275
61276
61277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
61278   int jresult ;
61279   int result;
61280
61281   {
61282     try {
61283       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
61284     } catch (std::out_of_range& e) {
61285       {
61286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61287       };
61288     } catch (std::exception& e) {
61289       {
61290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61291       };
61292     } catch (Dali::DaliException e) {
61293       {
61294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61295       };
61296     } catch (...) {
61297       {
61298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61299       };
61300     }
61301   }
61302
61303   jresult = (int)result;
61304   return jresult;
61305 }
61306
61307
61308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
61309   int jresult ;
61310   int result;
61311
61312   {
61313     try {
61314       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
61315     } catch (std::out_of_range& e) {
61316       {
61317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61318       };
61319     } catch (std::exception& e) {
61320       {
61321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61322       };
61323     } catch (Dali::DaliException e) {
61324       {
61325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61326       };
61327     } catch (...) {
61328       {
61329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61330       };
61331     }
61332   }
61333
61334   jresult = (int)result;
61335   return jresult;
61336 }
61337
61338
61339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
61340   int jresult ;
61341   int result;
61342
61343   {
61344     try {
61345       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
61346     } catch (std::out_of_range& e) {
61347       {
61348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61349       };
61350     } catch (std::exception& e) {
61351       {
61352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61353       };
61354     } catch (Dali::DaliException e) {
61355       {
61356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61357       };
61358     } catch (...) {
61359       {
61360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61361       };
61362     }
61363   }
61364
61365   jresult = (int)result;
61366   return jresult;
61367 }
61368
61369
61370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61371   int jresult ;
61372   int result;
61373
61374   {
61375     try {
61376       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61377     } catch (std::out_of_range& e) {
61378       {
61379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61380       };
61381     } catch (std::exception& e) {
61382       {
61383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61384       };
61385     } catch (Dali::DaliException e) {
61386       {
61387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61388       };
61389     } catch (...) {
61390       {
61391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61392       };
61393     }
61394   }
61395
61396   jresult = (int)result;
61397   return jresult;
61398 }
61399
61400
61401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61402   int jresult ;
61403   int result;
61404
61405   {
61406     try {
61407       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61408     } catch (std::out_of_range& e) {
61409       {
61410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61411       };
61412     } catch (std::exception& e) {
61413       {
61414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61415       };
61416     } catch (Dali::DaliException e) {
61417       {
61418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61419       };
61420     } catch (...) {
61421       {
61422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61423       };
61424     }
61425   }
61426
61427   jresult = (int)result;
61428   return jresult;
61429 }
61430
61431
61432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61433   int jresult ;
61434   int result;
61435
61436   {
61437     try {
61438       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61439     } catch (std::out_of_range& e) {
61440       {
61441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61442       };
61443     } catch (std::exception& e) {
61444       {
61445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61446       };
61447     } catch (Dali::DaliException e) {
61448       {
61449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61450       };
61451     } catch (...) {
61452       {
61453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61454       };
61455     }
61456   }
61457
61458   jresult = (int)result;
61459   return jresult;
61460 }
61461
61462
61463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61464   int jresult ;
61465   int result;
61466
61467   {
61468     try {
61469       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61470     } catch (std::out_of_range& e) {
61471       {
61472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61473       };
61474     } catch (std::exception& e) {
61475       {
61476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61477       };
61478     } catch (Dali::DaliException e) {
61479       {
61480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61481       };
61482     } catch (...) {
61483       {
61484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61485       };
61486     }
61487   }
61488
61489   jresult = (int)result;
61490   return jresult;
61491 }
61492
61493
61494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61495   int jresult ;
61496   int result;
61497
61498   {
61499     try {
61500       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61501     } catch (std::out_of_range& e) {
61502       {
61503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61504       };
61505     } catch (std::exception& e) {
61506       {
61507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61508       };
61509     } catch (Dali::DaliException e) {
61510       {
61511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61512       };
61513     } catch (...) {
61514       {
61515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61516       };
61517     }
61518   }
61519
61520   jresult = (int)result;
61521   return jresult;
61522 }
61523
61524
61525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61526   int jresult ;
61527   int result;
61528
61529   {
61530     try {
61531       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61532     } catch (std::out_of_range& e) {
61533       {
61534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61535       };
61536     } catch (std::exception& e) {
61537       {
61538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61539       };
61540     } catch (Dali::DaliException e) {
61541       {
61542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61543       };
61544     } catch (...) {
61545       {
61546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61547       };
61548     }
61549   }
61550
61551   jresult = (int)result;
61552   return jresult;
61553 }
61554
61555
61556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61557   int jresult ;
61558   int result;
61559
61560   {
61561     try {
61562       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61563     } catch (std::out_of_range& e) {
61564       {
61565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61566       };
61567     } catch (std::exception& e) {
61568       {
61569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61570       };
61571     } catch (Dali::DaliException e) {
61572       {
61573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61574       };
61575     } catch (...) {
61576       {
61577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61578       };
61579     }
61580   }
61581
61582   jresult = (int)result;
61583   return jresult;
61584 }
61585
61586
61587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61588   void * jresult ;
61589   Dali::Toolkit::Builder *result = 0 ;
61590
61591   {
61592     try {
61593       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61594     } catch (std::out_of_range& e) {
61595       {
61596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61597       };
61598     } catch (std::exception& e) {
61599       {
61600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61601       };
61602     } catch (Dali::DaliException e) {
61603       {
61604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61605       };
61606     } catch (...) {
61607       {
61608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61609       };
61610     }
61611   }
61612
61613   jresult = (void *)result;
61614   return jresult;
61615 }
61616
61617
61618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61619   void * jresult ;
61620   Dali::Toolkit::Builder result;
61621
61622   {
61623     try {
61624       result = Dali::Toolkit::Builder::New();
61625     } catch (std::out_of_range& e) {
61626       {
61627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61628       };
61629     } catch (std::exception& e) {
61630       {
61631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61632       };
61633     } catch (Dali::DaliException e) {
61634       {
61635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61636       };
61637     } catch (...) {
61638       {
61639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61640       };
61641     }
61642   }
61643
61644   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61645   return jresult;
61646 }
61647
61648
61649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61650   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61651
61652   arg1 = (Dali::Toolkit::Builder *)jarg1;
61653   {
61654     try {
61655       delete arg1;
61656     } catch (std::out_of_range& e) {
61657       {
61658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61659       };
61660     } catch (std::exception& e) {
61661       {
61662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61663       };
61664     } catch (Dali::DaliException e) {
61665       {
61666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61667       };
61668     } catch (...) {
61669       {
61670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61671       };
61672     }
61673   }
61674
61675 }
61676
61677
61678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61679   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61680   std::string *arg2 = 0 ;
61681   Dali::Toolkit::Builder::UIFormat arg3 ;
61682
61683   arg1 = (Dali::Toolkit::Builder *)jarg1;
61684   if (!jarg2) {
61685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61686     return ;
61687   }
61688   std::string arg2_str(jarg2);
61689   arg2 = &arg2_str;
61690   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61691   {
61692     try {
61693       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61694     } catch (std::out_of_range& e) {
61695       {
61696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61697       };
61698     } catch (std::exception& e) {
61699       {
61700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61701       };
61702     } catch (Dali::DaliException e) {
61703       {
61704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61705       };
61706     } catch (...) {
61707       {
61708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61709       };
61710     }
61711   }
61712
61713
61714   //argout typemap for const std::string&
61715
61716 }
61717
61718
61719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61720   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61721   std::string *arg2 = 0 ;
61722
61723   arg1 = (Dali::Toolkit::Builder *)jarg1;
61724   if (!jarg2) {
61725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61726     return ;
61727   }
61728   std::string arg2_str(jarg2);
61729   arg2 = &arg2_str;
61730   {
61731     try {
61732       (arg1)->LoadFromString((std::string const &)*arg2);
61733     } catch (std::out_of_range& e) {
61734       {
61735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61736       };
61737     } catch (std::exception& e) {
61738       {
61739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61740       };
61741     } catch (Dali::DaliException e) {
61742       {
61743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61744       };
61745     } catch (...) {
61746       {
61747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61748       };
61749     }
61750   }
61751
61752
61753   //argout typemap for const std::string&
61754
61755 }
61756
61757
61758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61759   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61760   Dali::Property::Map *arg2 = 0 ;
61761
61762   arg1 = (Dali::Toolkit::Builder *)jarg1;
61763   arg2 = (Dali::Property::Map *)jarg2;
61764   if (!arg2) {
61765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61766     return ;
61767   }
61768   {
61769     try {
61770       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61771     } catch (std::out_of_range& e) {
61772       {
61773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61774       };
61775     } catch (std::exception& e) {
61776       {
61777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61778       };
61779     } catch (Dali::DaliException e) {
61780       {
61781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61782       };
61783     } catch (...) {
61784       {
61785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61786       };
61787     }
61788   }
61789
61790 }
61791
61792
61793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61794   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61795   std::string *arg2 = 0 ;
61796   Dali::Property::Value *arg3 = 0 ;
61797
61798   arg1 = (Dali::Toolkit::Builder *)jarg1;
61799   if (!jarg2) {
61800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61801     return ;
61802   }
61803   std::string arg2_str(jarg2);
61804   arg2 = &arg2_str;
61805   arg3 = (Dali::Property::Value *)jarg3;
61806   if (!arg3) {
61807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61808     return ;
61809   }
61810   {
61811     try {
61812       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61813     } catch (std::out_of_range& e) {
61814       {
61815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61816       };
61817     } catch (std::exception& e) {
61818       {
61819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61820       };
61821     } catch (Dali::DaliException e) {
61822       {
61823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61824       };
61825     } catch (...) {
61826       {
61827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61828       };
61829     }
61830   }
61831
61832
61833   //argout typemap for const std::string&
61834
61835 }
61836
61837
61838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61839   void * jresult ;
61840   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61841   Dali::Property::Map *result = 0 ;
61842
61843   arg1 = (Dali::Toolkit::Builder *)jarg1;
61844   {
61845     try {
61846       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61847     } catch (std::out_of_range& e) {
61848       {
61849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61850       };
61851     } catch (std::exception& e) {
61852       {
61853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61854       };
61855     } catch (Dali::DaliException e) {
61856       {
61857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61858       };
61859     } catch (...) {
61860       {
61861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61862       };
61863     }
61864   }
61865
61866   jresult = (void *)result;
61867   return jresult;
61868 }
61869
61870
61871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61872   void * jresult ;
61873   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61874   std::string *arg2 = 0 ;
61875   Dali::Property::Value *result = 0 ;
61876
61877   arg1 = (Dali::Toolkit::Builder *)jarg1;
61878   if (!jarg2) {
61879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61880     return 0;
61881   }
61882   std::string arg2_str(jarg2);
61883   arg2 = &arg2_str;
61884   {
61885     try {
61886       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61887     } catch (std::out_of_range& e) {
61888       {
61889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61890       };
61891     } catch (std::exception& e) {
61892       {
61893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61894       };
61895     } catch (Dali::DaliException e) {
61896       {
61897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61898       };
61899     } catch (...) {
61900       {
61901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61902       };
61903     }
61904   }
61905
61906   jresult = (void *)result;
61907
61908   //argout typemap for const std::string&
61909
61910   return jresult;
61911 }
61912
61913
61914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61915   void * jresult ;
61916   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61917   std::string *arg2 = 0 ;
61918   Dali::Animation result;
61919
61920   arg1 = (Dali::Toolkit::Builder *)jarg1;
61921   if (!jarg2) {
61922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61923     return 0;
61924   }
61925   std::string arg2_str(jarg2);
61926   arg2 = &arg2_str;
61927   {
61928     try {
61929       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61930     } catch (std::out_of_range& e) {
61931       {
61932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61933       };
61934     } catch (std::exception& e) {
61935       {
61936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61937       };
61938     } catch (Dali::DaliException e) {
61939       {
61940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61941       };
61942     } catch (...) {
61943       {
61944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61945       };
61946     }
61947   }
61948
61949   jresult = new Dali::Animation((const Dali::Animation &)result);
61950
61951   //argout typemap for const std::string&
61952
61953   return jresult;
61954 }
61955
61956
61957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61958   void * jresult ;
61959   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61960   std::string *arg2 = 0 ;
61961   Dali::Property::Map *arg3 = 0 ;
61962   Dali::Animation result;
61963
61964   arg1 = (Dali::Toolkit::Builder *)jarg1;
61965   if (!jarg2) {
61966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61967     return 0;
61968   }
61969   std::string arg2_str(jarg2);
61970   arg2 = &arg2_str;
61971   arg3 = (Dali::Property::Map *)jarg3;
61972   if (!arg3) {
61973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61974     return 0;
61975   }
61976   {
61977     try {
61978       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61979     } catch (std::out_of_range& e) {
61980       {
61981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61982       };
61983     } catch (std::exception& e) {
61984       {
61985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61986       };
61987     } catch (Dali::DaliException e) {
61988       {
61989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61990       };
61991     } catch (...) {
61992       {
61993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61994       };
61995     }
61996   }
61997
61998   jresult = new Dali::Animation((const Dali::Animation &)result);
61999
62000   //argout typemap for const std::string&
62001
62002   return jresult;
62003 }
62004
62005
62006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
62007   void * jresult ;
62008   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62009   std::string *arg2 = 0 ;
62010   Dali::Actor arg3 ;
62011   Dali::Actor *argp3 ;
62012   Dali::Animation result;
62013
62014   arg1 = (Dali::Toolkit::Builder *)jarg1;
62015   if (!jarg2) {
62016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62017     return 0;
62018   }
62019   std::string arg2_str(jarg2);
62020   arg2 = &arg2_str;
62021   argp3 = (Dali::Actor *)jarg3;
62022   if (!argp3) {
62023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62024     return 0;
62025   }
62026   arg3 = *argp3;
62027   {
62028     try {
62029       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
62030     } catch (std::out_of_range& e) {
62031       {
62032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62033       };
62034     } catch (std::exception& e) {
62035       {
62036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62037       };
62038     } catch (Dali::DaliException e) {
62039       {
62040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62041       };
62042     } catch (...) {
62043       {
62044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62045       };
62046     }
62047   }
62048
62049   jresult = new Dali::Animation((const Dali::Animation &)result);
62050
62051   //argout typemap for const std::string&
62052
62053   return jresult;
62054 }
62055
62056
62057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
62058   void * jresult ;
62059   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62060   std::string *arg2 = 0 ;
62061   Dali::Property::Map *arg3 = 0 ;
62062   Dali::Actor arg4 ;
62063   Dali::Actor *argp4 ;
62064   Dali::Animation result;
62065
62066   arg1 = (Dali::Toolkit::Builder *)jarg1;
62067   if (!jarg2) {
62068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62069     return 0;
62070   }
62071   std::string arg2_str(jarg2);
62072   arg2 = &arg2_str;
62073   arg3 = (Dali::Property::Map *)jarg3;
62074   if (!arg3) {
62075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62076     return 0;
62077   }
62078   argp4 = (Dali::Actor *)jarg4;
62079   if (!argp4) {
62080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62081     return 0;
62082   }
62083   arg4 = *argp4;
62084   {
62085     try {
62086       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
62087     } catch (std::out_of_range& e) {
62088       {
62089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62090       };
62091     } catch (std::exception& e) {
62092       {
62093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62094       };
62095     } catch (Dali::DaliException e) {
62096       {
62097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62098       };
62099     } catch (...) {
62100       {
62101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62102       };
62103     }
62104   }
62105
62106   jresult = new Dali::Animation((const Dali::Animation &)result);
62107
62108   //argout typemap for const std::string&
62109
62110   return jresult;
62111 }
62112
62113
62114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
62115   void * jresult ;
62116   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62117   std::string *arg2 = 0 ;
62118   Dali::BaseHandle result;
62119
62120   arg1 = (Dali::Toolkit::Builder *)jarg1;
62121   if (!jarg2) {
62122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62123     return 0;
62124   }
62125   std::string arg2_str(jarg2);
62126   arg2 = &arg2_str;
62127   {
62128     try {
62129       result = (arg1)->Create((std::string const &)*arg2);
62130     } catch (std::out_of_range& e) {
62131       {
62132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62133       };
62134     } catch (std::exception& e) {
62135       {
62136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62137       };
62138     } catch (Dali::DaliException e) {
62139       {
62140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62141       };
62142     } catch (...) {
62143       {
62144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62145       };
62146     }
62147   }
62148
62149   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62150
62151   //argout typemap for const std::string&
62152
62153   return jresult;
62154 }
62155
62156
62157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62158   void * jresult ;
62159   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62160   std::string *arg2 = 0 ;
62161   Dali::Property::Map *arg3 = 0 ;
62162   Dali::BaseHandle result;
62163
62164   arg1 = (Dali::Toolkit::Builder *)jarg1;
62165   if (!jarg2) {
62166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62167     return 0;
62168   }
62169   std::string arg2_str(jarg2);
62170   arg2 = &arg2_str;
62171   arg3 = (Dali::Property::Map *)jarg3;
62172   if (!arg3) {
62173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62174     return 0;
62175   }
62176   {
62177     try {
62178       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
62179     } catch (std::out_of_range& e) {
62180       {
62181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62182       };
62183     } catch (std::exception& e) {
62184       {
62185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62186       };
62187     } catch (Dali::DaliException e) {
62188       {
62189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62190       };
62191     } catch (...) {
62192       {
62193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62194       };
62195     }
62196   }
62197
62198   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62199
62200   //argout typemap for const std::string&
62201
62202   return jresult;
62203 }
62204
62205
62206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
62207   void * jresult ;
62208   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62209   std::string *arg2 = 0 ;
62210   Dali::BaseHandle result;
62211
62212   arg1 = (Dali::Toolkit::Builder *)jarg1;
62213   if (!jarg2) {
62214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62215     return 0;
62216   }
62217   std::string arg2_str(jarg2);
62218   arg2 = &arg2_str;
62219   {
62220     try {
62221       result = (arg1)->CreateFromJson((std::string const &)*arg2);
62222     } catch (std::out_of_range& e) {
62223       {
62224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62225       };
62226     } catch (std::exception& e) {
62227       {
62228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62229       };
62230     } catch (Dali::DaliException e) {
62231       {
62232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62233       };
62234     } catch (...) {
62235       {
62236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62237       };
62238     }
62239   }
62240
62241   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62242
62243   //argout typemap for const std::string&
62244
62245   return jresult;
62246 }
62247
62248
62249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
62250   unsigned int jresult ;
62251   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62252   std::string *arg2 = 0 ;
62253   Dali::Handle *arg3 = 0 ;
62254   bool result;
62255
62256   arg1 = (Dali::Toolkit::Builder *)jarg1;
62257   if (!jarg2) {
62258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62259     return 0;
62260   }
62261   std::string arg2_str(jarg2);
62262   arg2 = &arg2_str;
62263   arg3 = (Dali::Handle *)jarg3;
62264   if (!arg3) {
62265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62266     return 0;
62267   }
62268   {
62269     try {
62270       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
62271     } catch (std::out_of_range& e) {
62272       {
62273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62274       };
62275     } catch (std::exception& e) {
62276       {
62277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62278       };
62279     } catch (Dali::DaliException e) {
62280       {
62281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62282       };
62283     } catch (...) {
62284       {
62285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62286       };
62287     }
62288   }
62289
62290   jresult = result;
62291
62292   //argout typemap for const std::string&
62293
62294   return jresult;
62295 }
62296
62297
62298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
62299   unsigned int jresult ;
62300   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62301   Dali::Handle *arg2 = 0 ;
62302   std::string *arg3 = 0 ;
62303   bool result;
62304
62305   arg1 = (Dali::Toolkit::Builder *)jarg1;
62306   arg2 = (Dali::Handle *)jarg2;
62307   if (!arg2) {
62308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62309     return 0;
62310   }
62311   if (!jarg3) {
62312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62313     return 0;
62314   }
62315   std::string arg3_str(jarg3);
62316   arg3 = &arg3_str;
62317   {
62318     try {
62319       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
62320     } catch (std::out_of_range& e) {
62321       {
62322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62323       };
62324     } catch (std::exception& e) {
62325       {
62326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62327       };
62328     } catch (Dali::DaliException e) {
62329       {
62330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62331       };
62332     } catch (...) {
62333       {
62334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62335       };
62336     }
62337   }
62338
62339   jresult = result;
62340
62341   //argout typemap for const std::string&
62342
62343   return jresult;
62344 }
62345
62346
62347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
62348   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62349   Dali::Actor arg2 ;
62350   Dali::Actor *argp2 ;
62351
62352   arg1 = (Dali::Toolkit::Builder *)jarg1;
62353   argp2 = (Dali::Actor *)jarg2;
62354   if (!argp2) {
62355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62356     return ;
62357   }
62358   arg2 = *argp2;
62359   {
62360     try {
62361       (arg1)->AddActors(arg2);
62362     } catch (std::out_of_range& e) {
62363       {
62364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62365       };
62366     } catch (std::exception& e) {
62367       {
62368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62369       };
62370     } catch (Dali::DaliException e) {
62371       {
62372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62373       };
62374     } catch (...) {
62375       {
62376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62377       };
62378     }
62379   }
62380
62381 }
62382
62383
62384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62385   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62386   std::string *arg2 = 0 ;
62387   Dali::Actor arg3 ;
62388   Dali::Actor *argp3 ;
62389
62390   arg1 = (Dali::Toolkit::Builder *)jarg1;
62391   if (!jarg2) {
62392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62393     return ;
62394   }
62395   std::string arg2_str(jarg2);
62396   arg2 = &arg2_str;
62397   argp3 = (Dali::Actor *)jarg3;
62398   if (!argp3) {
62399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62400     return ;
62401   }
62402   arg3 = *argp3;
62403   {
62404     try {
62405       (arg1)->AddActors((std::string const &)*arg2,arg3);
62406     } catch (std::out_of_range& e) {
62407       {
62408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62409       };
62410     } catch (std::exception& e) {
62411       {
62412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62413       };
62414     } catch (Dali::DaliException e) {
62415       {
62416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62417       };
62418     } catch (...) {
62419       {
62420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62421       };
62422     }
62423   }
62424
62425
62426   //argout typemap for const std::string&
62427
62428 }
62429
62430
62431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62432   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62433   std::string *arg2 = 0 ;
62434
62435   arg1 = (Dali::Toolkit::Builder *)jarg1;
62436   if (!jarg2) {
62437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62438     return ;
62439   }
62440   std::string arg2_str(jarg2);
62441   arg2 = &arg2_str;
62442   {
62443     try {
62444       (arg1)->CreateRenderTask((std::string const &)*arg2);
62445     } catch (std::out_of_range& e) {
62446       {
62447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62448       };
62449     } catch (std::exception& e) {
62450       {
62451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62452       };
62453     } catch (Dali::DaliException e) {
62454       {
62455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62456       };
62457     } catch (...) {
62458       {
62459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62460       };
62461     }
62462   }
62463
62464
62465   //argout typemap for const std::string&
62466
62467 }
62468
62469
62470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
62471   void * jresult ;
62472   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62473   std::string *arg2 = 0 ;
62474   Dali::FrameBufferImage result;
62475
62476   arg1 = (Dali::Toolkit::Builder *)jarg1;
62477   if (!jarg2) {
62478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62479     return 0;
62480   }
62481   std::string arg2_str(jarg2);
62482   arg2 = &arg2_str;
62483   {
62484     try {
62485       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62486     } catch (std::out_of_range& e) {
62487       {
62488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62489       };
62490     } catch (std::exception& e) {
62491       {
62492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62493       };
62494     } catch (Dali::DaliException e) {
62495       {
62496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62497       };
62498     } catch (...) {
62499       {
62500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62501       };
62502     }
62503   }
62504
62505   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62506
62507   //argout typemap for const std::string&
62508
62509   return jresult;
62510 }
62511
62512
62513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62514   void * jresult ;
62515   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62516   std::string *arg2 = 0 ;
62517   Dali::Path result;
62518
62519   arg1 = (Dali::Toolkit::Builder *)jarg1;
62520   if (!jarg2) {
62521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62522     return 0;
62523   }
62524   std::string arg2_str(jarg2);
62525   arg2 = &arg2_str;
62526   {
62527     try {
62528       result = (arg1)->GetPath((std::string const &)*arg2);
62529     } catch (std::out_of_range& e) {
62530       {
62531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62532       };
62533     } catch (std::exception& e) {
62534       {
62535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62536       };
62537     } catch (Dali::DaliException e) {
62538       {
62539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62540       };
62541     } catch (...) {
62542       {
62543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62544       };
62545     }
62546   }
62547
62548   jresult = new Dali::Path((const Dali::Path &)result);
62549
62550   //argout typemap for const std::string&
62551
62552   return jresult;
62553 }
62554
62555
62556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62557   void * jresult ;
62558   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62559   std::string *arg2 = 0 ;
62560   Dali::PathConstrainer result;
62561
62562   arg1 = (Dali::Toolkit::Builder *)jarg1;
62563   if (!jarg2) {
62564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62565     return 0;
62566   }
62567   std::string arg2_str(jarg2);
62568   arg2 = &arg2_str;
62569   {
62570     try {
62571       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62572     } catch (std::out_of_range& e) {
62573       {
62574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62575       };
62576     } catch (std::exception& e) {
62577       {
62578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62579       };
62580     } catch (Dali::DaliException e) {
62581       {
62582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62583       };
62584     } catch (...) {
62585       {
62586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62587       };
62588     }
62589   }
62590
62591   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62592
62593   //argout typemap for const std::string&
62594
62595   return jresult;
62596 }
62597
62598
62599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62600   void * jresult ;
62601   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62602   std::string *arg2 = 0 ;
62603   Dali::LinearConstrainer result;
62604
62605   arg1 = (Dali::Toolkit::Builder *)jarg1;
62606   if (!jarg2) {
62607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62608     return 0;
62609   }
62610   std::string arg2_str(jarg2);
62611   arg2 = &arg2_str;
62612   {
62613     try {
62614       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62615     } catch (std::out_of_range& e) {
62616       {
62617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62618       };
62619     } catch (std::exception& e) {
62620       {
62621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62622       };
62623     } catch (Dali::DaliException e) {
62624       {
62625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62626       };
62627     } catch (...) {
62628       {
62629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62630       };
62631     }
62632   }
62633
62634   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62635
62636   //argout typemap for const std::string&
62637
62638   return jresult;
62639 }
62640
62641
62642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62643   void * jresult ;
62644   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62645   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62646
62647   arg1 = (Dali::Toolkit::Builder *)jarg1;
62648   {
62649     try {
62650       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62651     } catch (std::out_of_range& e) {
62652       {
62653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62654       };
62655     } catch (std::exception& e) {
62656       {
62657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62658       };
62659     } catch (Dali::DaliException e) {
62660       {
62661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62662       };
62663     } catch (...) {
62664       {
62665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62666       };
62667     }
62668   }
62669
62670   jresult = (void *)result;
62671   return jresult;
62672 }
62673
62674
62675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62676   void * jresult ;
62677   Dali::Toolkit::TransitionData *result = 0 ;
62678
62679   {
62680     try {
62681       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62682     } catch (std::out_of_range& e) {
62683       {
62684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62685       };
62686     } catch (std::exception& e) {
62687       {
62688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62689       };
62690     } catch (Dali::DaliException e) {
62691       {
62692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62693       };
62694     } catch (...) {
62695       {
62696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62697       };
62698     }
62699   }
62700
62701   jresult = (void *)result;
62702   return jresult;
62703 }
62704
62705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62706   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62707
62708   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62709   {
62710     try {
62711       delete arg1;
62712     } catch (std::out_of_range& e) {
62713       {
62714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62715       };
62716     } catch (std::exception& e) {
62717       {
62718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62719       };
62720     } catch (Dali::DaliException e) {
62721       {
62722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62723       };
62724     } catch (...) {
62725       {
62726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62727       };
62728     }
62729   }
62730
62731 }
62732
62733
62734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62735   void * jresult ;
62736   Dali::Property::Map *arg1 = 0 ;
62737   Dali::Toolkit::TransitionData result;
62738
62739   arg1 = (Dali::Property::Map *)jarg1;
62740   if (!arg1) {
62741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62742     return 0;
62743   }
62744   {
62745     try {
62746       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62747     } catch (std::out_of_range& e) {
62748       {
62749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62750       };
62751     } catch (std::exception& e) {
62752       {
62753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62754       };
62755     } catch (Dali::DaliException e) {
62756       {
62757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62758       };
62759     } catch (...) {
62760       {
62761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62762       };
62763     }
62764   }
62765
62766   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62767   return jresult;
62768 }
62769
62770
62771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62772   void * jresult ;
62773   Dali::Property::Array *arg1 = 0 ;
62774   Dali::Toolkit::TransitionData result;
62775
62776   arg1 = (Dali::Property::Array *)jarg1;
62777   if (!arg1) {
62778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62779     return 0;
62780   }
62781   {
62782     try {
62783       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array 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_DownCast(void * jarg1) {
62809   void * jresult ;
62810   Dali::BaseHandle arg1 ;
62811   Dali::BaseHandle *argp1 ;
62812   Dali::Toolkit::TransitionData result;
62813
62814   argp1 = (Dali::BaseHandle *)jarg1;
62815   if (!argp1) {
62816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62817     return 0;
62818   }
62819   arg1 = *argp1;
62820   {
62821     try {
62822       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62823     } catch (std::out_of_range& e) {
62824       {
62825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62826       };
62827     } catch (std::exception& e) {
62828       {
62829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62830       };
62831     } catch (Dali::DaliException e) {
62832       {
62833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62834       };
62835     } catch (...) {
62836       {
62837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62838       };
62839     }
62840   }
62841
62842   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62843   return jresult;
62844 }
62845
62846
62847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62848   void * jresult ;
62849   Dali::Toolkit::TransitionData *arg1 = 0 ;
62850   Dali::Toolkit::TransitionData *result = 0 ;
62851
62852   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62853   if (!arg1) {
62854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62855     return 0;
62856   }
62857   {
62858     try {
62859       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*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 = (void *)result;
62880   return jresult;
62881 }
62882
62883
62884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62885   void * jresult ;
62886   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62887   Dali::Toolkit::TransitionData *arg2 = 0 ;
62888   Dali::Toolkit::TransitionData *result = 0 ;
62889
62890   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62891   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62892   if (!arg2) {
62893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62894     return 0;
62895   }
62896   {
62897     try {
62898       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62899     } catch (std::out_of_range& e) {
62900       {
62901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62902       };
62903     } catch (std::exception& e) {
62904       {
62905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62906       };
62907     } catch (Dali::DaliException e) {
62908       {
62909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62910       };
62911     } catch (...) {
62912       {
62913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62914       };
62915     }
62916   }
62917
62918   jresult = (void *)result;
62919   return jresult;
62920 }
62921
62922
62923 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62924   unsigned long jresult ;
62925   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62926   size_t result;
62927
62928   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62929   {
62930     try {
62931       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62932     } catch (std::out_of_range& e) {
62933       {
62934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62935       };
62936     } catch (std::exception& e) {
62937       {
62938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62939       };
62940     } catch (Dali::DaliException e) {
62941       {
62942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62943       };
62944     } catch (...) {
62945       {
62946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62947       };
62948     }
62949   }
62950
62951   jresult = (unsigned long)result;
62952   return jresult;
62953 }
62954
62955
62956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62957   void * jresult ;
62958   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62959   size_t arg2 ;
62960   Dali::Property::Map result;
62961
62962   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62963   arg2 = (size_t)jarg2;
62964   {
62965     try {
62966       result = (arg1)->GetAnimatorAt(arg2);
62967     } catch (std::out_of_range& e) {
62968       {
62969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62970       };
62971     } catch (std::exception& e) {
62972       {
62973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62974       };
62975     } catch (Dali::DaliException e) {
62976       {
62977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62978       };
62979     } catch (...) {
62980       {
62981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62982       };
62983     }
62984   }
62985
62986   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62987   return jresult;
62988 }
62989
62990
62991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
62992   void * jresult ;
62993   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
62994   Dali::Toolkit::TransitionData *result = 0 ;
62995
62996   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
62997   {
62998     try {
62999       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
63000     } catch (std::out_of_range& e) {
63001       {
63002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63003       };
63004     } catch (std::exception& e) {
63005       {
63006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63007       };
63008     } catch (Dali::DaliException e) {
63009       {
63010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63011       };
63012     } catch (...) {
63013       {
63014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63015       };
63016     }
63017   }
63018
63019   jresult = (void *)result;
63020   return jresult;
63021 }
63022
63023
63024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
63025   int jresult ;
63026   int result;
63027
63028   {
63029     try {
63030       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
63031     } catch (std::out_of_range& e) {
63032       {
63033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63034       };
63035     } catch (std::exception& e) {
63036       {
63037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63038       };
63039     } catch (Dali::DaliException e) {
63040       {
63041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63042       };
63043     } catch (...) {
63044       {
63045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63046       };
63047     }
63048   }
63049
63050   jresult = (int)result;
63051   return jresult;
63052 }
63053
63054
63055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
63056   int jresult ;
63057   int result;
63058
63059   {
63060     try {
63061       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
63062     } catch (std::out_of_range& e) {
63063       {
63064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63065       };
63066     } catch (std::exception& e) {
63067       {
63068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63069       };
63070     } catch (Dali::DaliException e) {
63071       {
63072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63073       };
63074     } catch (...) {
63075       {
63076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63077       };
63078     }
63079   }
63080
63081   jresult = (int)result;
63082   return jresult;
63083 }
63084
63085
63086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
63087   int jresult ;
63088   int result;
63089
63090   {
63091     try {
63092       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
63093     } catch (std::out_of_range& e) {
63094       {
63095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63096       };
63097     } catch (std::exception& e) {
63098       {
63099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63100       };
63101     } catch (Dali::DaliException e) {
63102       {
63103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63104       };
63105     } catch (...) {
63106       {
63107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63108       };
63109     }
63110   }
63111
63112   jresult = (int)result;
63113   return jresult;
63114 }
63115
63116
63117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
63118   int jresult ;
63119   int result;
63120
63121   {
63122     try {
63123       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
63124     } catch (std::out_of_range& e) {
63125       {
63126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63127       };
63128     } catch (std::exception& e) {
63129       {
63130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63131       };
63132     } catch (Dali::DaliException e) {
63133       {
63134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63135       };
63136     } catch (...) {
63137       {
63138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63139       };
63140     }
63141   }
63142
63143   jresult = (int)result;
63144   return jresult;
63145 }
63146
63147
63148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
63149   int jresult ;
63150   int result;
63151
63152   {
63153     try {
63154       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
63155     } catch (std::out_of_range& e) {
63156       {
63157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63158       };
63159     } catch (std::exception& e) {
63160       {
63161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63162       };
63163     } catch (Dali::DaliException e) {
63164       {
63165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63166       };
63167     } catch (...) {
63168       {
63169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63170       };
63171     }
63172   }
63173
63174   jresult = (int)result;
63175   return jresult;
63176 }
63177
63178
63179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
63180   int jresult ;
63181   int result;
63182
63183   {
63184     try {
63185       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
63186     } catch (std::out_of_range& e) {
63187       {
63188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63189       };
63190     } catch (std::exception& e) {
63191       {
63192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63193       };
63194     } catch (Dali::DaliException e) {
63195       {
63196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63197       };
63198     } catch (...) {
63199       {
63200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63201       };
63202     }
63203   }
63204
63205   jresult = (int)result;
63206   return jresult;
63207 }
63208
63209
63210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
63211   int jresult ;
63212   int result;
63213
63214   {
63215     try {
63216       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
63217     } catch (std::out_of_range& e) {
63218       {
63219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63220       };
63221     } catch (std::exception& e) {
63222       {
63223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63224       };
63225     } catch (Dali::DaliException e) {
63226       {
63227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63228       };
63229     } catch (...) {
63230       {
63231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63232       };
63233     }
63234   }
63235
63236   jresult = (int)result;
63237   return jresult;
63238 }
63239
63240
63241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
63242   int jresult ;
63243   int result;
63244
63245   {
63246     try {
63247       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
63248     } catch (std::out_of_range& e) {
63249       {
63250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63251       };
63252     } catch (std::exception& e) {
63253       {
63254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63255       };
63256     } catch (Dali::DaliException e) {
63257       {
63258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63259       };
63260     } catch (...) {
63261       {
63262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63263       };
63264     }
63265   }
63266
63267   jresult = (int)result;
63268   return jresult;
63269 }
63270
63271
63272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
63273   int jresult ;
63274   int result;
63275
63276   {
63277     try {
63278       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
63279     } catch (std::out_of_range& e) {
63280       {
63281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63282       };
63283     } catch (std::exception& e) {
63284       {
63285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63286       };
63287     } catch (Dali::DaliException e) {
63288       {
63289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63290       };
63291     } catch (...) {
63292       {
63293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63294       };
63295     }
63296   }
63297
63298   jresult = (int)result;
63299   return jresult;
63300 }
63301
63302
63303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
63304   int jresult ;
63305   int result;
63306
63307   {
63308     try {
63309       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
63310     } catch (std::out_of_range& e) {
63311       {
63312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63313       };
63314     } catch (std::exception& e) {
63315       {
63316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63317       };
63318     } catch (Dali::DaliException e) {
63319       {
63320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63321       };
63322     } catch (...) {
63323       {
63324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63325       };
63326     }
63327   }
63328
63329   jresult = (int)result;
63330   return jresult;
63331 }
63332
63333
63334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
63335   int jresult ;
63336   int result;
63337
63338   {
63339     try {
63340       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
63341     } catch (std::out_of_range& e) {
63342       {
63343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63344       };
63345     } catch (std::exception& e) {
63346       {
63347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63348       };
63349     } catch (Dali::DaliException e) {
63350       {
63351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63352       };
63353     } catch (...) {
63354       {
63355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63356       };
63357     }
63358   }
63359
63360   jresult = (int)result;
63361   return jresult;
63362 }
63363
63364
63365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
63366   int jresult ;
63367   int result;
63368
63369   {
63370     try {
63371       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
63372     } catch (std::out_of_range& e) {
63373       {
63374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63375       };
63376     } catch (std::exception& e) {
63377       {
63378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63379       };
63380     } catch (Dali::DaliException e) {
63381       {
63382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63383       };
63384     } catch (...) {
63385       {
63386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63387       };
63388     }
63389   }
63390
63391   jresult = (int)result;
63392   return jresult;
63393 }
63394
63395
63396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
63397   int jresult ;
63398   int result;
63399
63400   {
63401     try {
63402       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
63403     } catch (std::out_of_range& e) {
63404       {
63405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63406       };
63407     } catch (std::exception& e) {
63408       {
63409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63410       };
63411     } catch (Dali::DaliException e) {
63412       {
63413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63414       };
63415     } catch (...) {
63416       {
63417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63418       };
63419     }
63420   }
63421
63422   jresult = (int)result;
63423   return jresult;
63424 }
63425
63426
63427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
63428   int jresult ;
63429   int result;
63430
63431   {
63432     try {
63433       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63434     } catch (std::out_of_range& e) {
63435       {
63436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63437       };
63438     } catch (std::exception& e) {
63439       {
63440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63441       };
63442     } catch (Dali::DaliException e) {
63443       {
63444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63445       };
63446     } catch (...) {
63447       {
63448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63449       };
63450     }
63451   }
63452
63453   jresult = (int)result;
63454   return jresult;
63455 }
63456
63457
63458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63459   void * jresult ;
63460   Dali::Toolkit::Control result;
63461
63462   {
63463     try {
63464       result = Dali::Toolkit::Internal::Control::New();
63465     } catch (std::out_of_range& e) {
63466       {
63467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63468       };
63469     } catch (std::exception& e) {
63470       {
63471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63472       };
63473     } catch (Dali::DaliException e) {
63474       {
63475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63476       };
63477     } catch (...) {
63478       {
63479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63480       };
63481     }
63482   }
63483
63484   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63485   return jresult;
63486 }
63487
63488
63489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63490   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63491   std::string *arg2 = 0 ;
63492
63493   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63494   if (!jarg2) {
63495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63496     return ;
63497   }
63498   std::string arg2_str(jarg2);
63499   arg2 = &arg2_str;
63500   {
63501     try {
63502       (arg1)->SetStyleName((std::string const &)*arg2);
63503     } catch (std::out_of_range& e) {
63504       {
63505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63506       };
63507     } catch (std::exception& e) {
63508       {
63509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63510       };
63511     } catch (Dali::DaliException e) {
63512       {
63513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63514       };
63515     } catch (...) {
63516       {
63517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63518       };
63519     }
63520   }
63521
63522
63523   //argout typemap for const std::string&
63524
63525 }
63526
63527
63528 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63529   char * jresult ;
63530   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63531   std::string *result = 0 ;
63532
63533   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63534   {
63535     try {
63536       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63537     } catch (std::out_of_range& e) {
63538       {
63539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63540       };
63541     } catch (std::exception& e) {
63542       {
63543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63544       };
63545     } catch (Dali::DaliException e) {
63546       {
63547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63548       };
63549     } catch (...) {
63550       {
63551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63552       };
63553     }
63554   }
63555
63556   jresult = SWIG_csharp_string_callback(result->c_str());
63557   return jresult;
63558 }
63559
63560
63561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63562   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63563   Dali::Vector4 *arg2 = 0 ;
63564
63565   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63566   arg2 = (Dali::Vector4 *)jarg2;
63567   if (!arg2) {
63568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63569     return ;
63570   }
63571   {
63572     try {
63573       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63574     } catch (std::out_of_range& e) {
63575       {
63576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63577       };
63578     } catch (std::exception& e) {
63579       {
63580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63581       };
63582     } catch (Dali::DaliException e) {
63583       {
63584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63585       };
63586     } catch (...) {
63587       {
63588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63589       };
63590     }
63591   }
63592
63593 }
63594
63595
63596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63597   void * jresult ;
63598   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63599   Dali::Vector4 result;
63600
63601   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63602   {
63603     try {
63604       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63605     } catch (std::out_of_range& e) {
63606       {
63607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63608       };
63609     } catch (std::exception& e) {
63610       {
63611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63612       };
63613     } catch (Dali::DaliException e) {
63614       {
63615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63616       };
63617     } catch (...) {
63618       {
63619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63620       };
63621     }
63622   }
63623
63624   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63625   return jresult;
63626 }
63627
63628
63629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63630   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63631   Dali::Image arg2 ;
63632   Dali::Image *argp2 ;
63633
63634   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63635   argp2 = (Dali::Image *)jarg2;
63636   if (!argp2) {
63637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63638     return ;
63639   }
63640   arg2 = *argp2;
63641   {
63642     try {
63643       (arg1)->SetBackgroundImage(arg2);
63644     } catch (std::out_of_range& e) {
63645       {
63646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63647       };
63648     } catch (std::exception& e) {
63649       {
63650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63651       };
63652     } catch (Dali::DaliException e) {
63653       {
63654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63655       };
63656     } catch (...) {
63657       {
63658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63659       };
63660     }
63661   }
63662
63663 }
63664
63665
63666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63667   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63668   Dali::Property::Map *arg2 = 0 ;
63669
63670   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63671   arg2 = (Dali::Property::Map *)jarg2;
63672   if (!arg2) {
63673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63674     return ;
63675   }
63676   {
63677     try {
63678       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63679     } catch (std::out_of_range& e) {
63680       {
63681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63682       };
63683     } catch (std::exception& e) {
63684       {
63685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63686       };
63687     } catch (Dali::DaliException e) {
63688       {
63689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63690       };
63691     } catch (...) {
63692       {
63693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63694       };
63695     }
63696   }
63697
63698 }
63699
63700
63701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63702   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63703
63704   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63705   {
63706     try {
63707       (arg1)->ClearBackground();
63708     } catch (std::out_of_range& e) {
63709       {
63710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63711       };
63712     } catch (std::exception& e) {
63713       {
63714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63715       };
63716     } catch (Dali::DaliException e) {
63717       {
63718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63719       };
63720     } catch (...) {
63721       {
63722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63723       };
63724     }
63725   }
63726
63727 }
63728
63729
63730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63731   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63732   Dali::Gesture::Type arg2 ;
63733
63734   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63735   arg2 = (Dali::Gesture::Type)jarg2;
63736   {
63737     try {
63738       (arg1)->EnableGestureDetection(arg2);
63739     } catch (std::out_of_range& e) {
63740       {
63741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63742       };
63743     } catch (std::exception& e) {
63744       {
63745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63746       };
63747     } catch (Dali::DaliException e) {
63748       {
63749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63750       };
63751     } catch (...) {
63752       {
63753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63754       };
63755     }
63756   }
63757
63758 }
63759
63760
63761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63762   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63763   Dali::Gesture::Type arg2 ;
63764
63765   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63766   arg2 = (Dali::Gesture::Type)jarg2;
63767   {
63768     try {
63769       (arg1)->DisableGestureDetection(arg2);
63770     } catch (std::out_of_range& e) {
63771       {
63772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63773       };
63774     } catch (std::exception& e) {
63775       {
63776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63777       };
63778     } catch (Dali::DaliException e) {
63779       {
63780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63781       };
63782     } catch (...) {
63783       {
63784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63785       };
63786     }
63787   }
63788
63789 }
63790
63791
63792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63793   void * jresult ;
63794   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63795   Dali::PinchGestureDetector result;
63796
63797   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63798   {
63799     try {
63800       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63801     } catch (std::out_of_range& e) {
63802       {
63803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63804       };
63805     } catch (std::exception& e) {
63806       {
63807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63808       };
63809     } catch (Dali::DaliException e) {
63810       {
63811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63812       };
63813     } catch (...) {
63814       {
63815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63816       };
63817     }
63818   }
63819
63820   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63821   return jresult;
63822 }
63823
63824
63825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63826   void * jresult ;
63827   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63828   Dali::PanGestureDetector result;
63829
63830   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63831   {
63832     try {
63833       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63834     } catch (std::out_of_range& e) {
63835       {
63836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63837       };
63838     } catch (std::exception& e) {
63839       {
63840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63841       };
63842     } catch (Dali::DaliException e) {
63843       {
63844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63845       };
63846     } catch (...) {
63847       {
63848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63849       };
63850     }
63851   }
63852
63853   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63854   return jresult;
63855 }
63856
63857
63858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63859   void * jresult ;
63860   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63861   Dali::TapGestureDetector result;
63862
63863   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63864   {
63865     try {
63866       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63867     } catch (std::out_of_range& e) {
63868       {
63869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63870       };
63871     } catch (std::exception& e) {
63872       {
63873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63874       };
63875     } catch (Dali::DaliException e) {
63876       {
63877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63878       };
63879     } catch (...) {
63880       {
63881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63882       };
63883     }
63884   }
63885
63886   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63887   return jresult;
63888 }
63889
63890
63891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63892   void * jresult ;
63893   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63894   Dali::LongPressGestureDetector result;
63895
63896   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63897   {
63898     try {
63899       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63900     } catch (std::out_of_range& e) {
63901       {
63902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63903       };
63904     } catch (std::exception& e) {
63905       {
63906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63907       };
63908     } catch (Dali::DaliException e) {
63909       {
63910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63911       };
63912     } catch (...) {
63913       {
63914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63915       };
63916     }
63917   }
63918
63919   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63920   return jresult;
63921 }
63922
63923
63924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63925   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63926   bool arg2 ;
63927
63928   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63929   arg2 = jarg2 ? true : false;
63930   {
63931     try {
63932       (arg1)->SetKeyboardNavigationSupport(arg2);
63933     } catch (std::out_of_range& e) {
63934       {
63935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63936       };
63937     } catch (std::exception& e) {
63938       {
63939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63940       };
63941     } catch (Dali::DaliException e) {
63942       {
63943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63944       };
63945     } catch (...) {
63946       {
63947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63948       };
63949     }
63950   }
63951
63952 }
63953
63954
63955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63956   unsigned int jresult ;
63957   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63958   bool result;
63959
63960   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63961   {
63962     try {
63963       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63964     } catch (std::out_of_range& e) {
63965       {
63966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63967       };
63968     } catch (std::exception& e) {
63969       {
63970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63971       };
63972     } catch (Dali::DaliException e) {
63973       {
63974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63975       };
63976     } catch (...) {
63977       {
63978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63979       };
63980     }
63981   }
63982
63983   jresult = result;
63984   return jresult;
63985 }
63986
63987
63988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63989   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63990
63991   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63992   {
63993     try {
63994       (arg1)->SetKeyInputFocus();
63995     } catch (std::out_of_range& e) {
63996       {
63997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63998       };
63999     } catch (std::exception& e) {
64000       {
64001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64002       };
64003     } catch (Dali::DaliException e) {
64004       {
64005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64006       };
64007     } catch (...) {
64008       {
64009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64010       };
64011     }
64012   }
64013
64014 }
64015
64016
64017 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
64018   unsigned int jresult ;
64019   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64020   bool result;
64021
64022   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64023   {
64024     try {
64025       result = (bool)(arg1)->HasKeyInputFocus();
64026     } catch (std::out_of_range& e) {
64027       {
64028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64029       };
64030     } catch (std::exception& e) {
64031       {
64032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64033       };
64034     } catch (Dali::DaliException e) {
64035       {
64036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64037       };
64038     } catch (...) {
64039       {
64040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64041       };
64042     }
64043   }
64044
64045   jresult = result;
64046   return jresult;
64047 }
64048
64049
64050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
64051   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64052
64053   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64054   {
64055     try {
64056       (arg1)->ClearKeyInputFocus();
64057     } catch (std::out_of_range& e) {
64058       {
64059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64060       };
64061     } catch (std::exception& e) {
64062       {
64063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64064       };
64065     } catch (Dali::DaliException e) {
64066       {
64067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64068       };
64069     } catch (...) {
64070       {
64071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64072       };
64073     }
64074   }
64075
64076 }
64077
64078
64079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
64080   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64081   bool arg2 ;
64082
64083   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64084   arg2 = jarg2 ? true : false;
64085   {
64086     try {
64087       (arg1)->SetAsKeyboardFocusGroup(arg2);
64088     } catch (std::out_of_range& e) {
64089       {
64090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64091       };
64092     } catch (std::exception& e) {
64093       {
64094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64095       };
64096     } catch (Dali::DaliException e) {
64097       {
64098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64099       };
64100     } catch (...) {
64101       {
64102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64103       };
64104     }
64105   }
64106
64107 }
64108
64109
64110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
64111   unsigned int jresult ;
64112   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64113   bool result;
64114
64115   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64116   {
64117     try {
64118       result = (bool)(arg1)->IsKeyboardFocusGroup();
64119     } catch (std::out_of_range& e) {
64120       {
64121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64122       };
64123     } catch (std::exception& e) {
64124       {
64125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64126       };
64127     } catch (Dali::DaliException e) {
64128       {
64129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64130       };
64131     } catch (...) {
64132       {
64133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64134       };
64135     }
64136   }
64137
64138   jresult = result;
64139   return jresult;
64140 }
64141
64142
64143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
64144   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64145
64146   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64147   {
64148     try {
64149       (arg1)->AccessibilityActivate();
64150     } catch (std::out_of_range& e) {
64151       {
64152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64153       };
64154     } catch (std::exception& e) {
64155       {
64156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64157       };
64158     } catch (Dali::DaliException e) {
64159       {
64160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64161       };
64162     } catch (...) {
64163       {
64164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64165       };
64166     }
64167   }
64168
64169 }
64170
64171
64172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
64173   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64174
64175   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64176   {
64177     try {
64178       (arg1)->KeyboardEnter();
64179     } catch (std::out_of_range& e) {
64180       {
64181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64182       };
64183     } catch (std::exception& e) {
64184       {
64185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64186       };
64187     } catch (Dali::DaliException e) {
64188       {
64189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64190       };
64191     } catch (...) {
64192       {
64193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64194       };
64195     }
64196   }
64197
64198 }
64199
64200
64201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
64202   void * jresult ;
64203   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64204   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
64205
64206   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64207   {
64208     try {
64209       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
64210     } catch (std::out_of_range& e) {
64211       {
64212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64213       };
64214     } catch (std::exception& e) {
64215       {
64216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64217       };
64218     } catch (Dali::DaliException e) {
64219       {
64220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64221       };
64222     } catch (...) {
64223       {
64224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64225       };
64226     }
64227   }
64228
64229   jresult = (void *)result;
64230   return jresult;
64231 }
64232
64233
64234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
64235   void * jresult ;
64236   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64237   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64238
64239   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64240   {
64241     try {
64242       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64243     } catch (std::out_of_range& e) {
64244       {
64245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64246       };
64247     } catch (std::exception& e) {
64248       {
64249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64250       };
64251     } catch (Dali::DaliException e) {
64252       {
64253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64254       };
64255     } catch (...) {
64256       {
64257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64258       };
64259     }
64260   }
64261
64262   jresult = (void *)result;
64263   return jresult;
64264 }
64265
64266
64267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
64268   void * jresult ;
64269   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64270   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64271
64272   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64273   {
64274     try {
64275       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64276     } catch (std::out_of_range& e) {
64277       {
64278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64279       };
64280     } catch (std::exception& e) {
64281       {
64282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64283       };
64284     } catch (Dali::DaliException e) {
64285       {
64286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64287       };
64288     } catch (...) {
64289       {
64290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64291       };
64292     }
64293   }
64294
64295   jresult = (void *)result;
64296   return jresult;
64297 }
64298
64299
64300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
64301   unsigned int jresult ;
64302   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64303   Dali::KeyEvent *arg2 = 0 ;
64304   bool result;
64305
64306   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64307   arg2 = (Dali::KeyEvent *)jarg2;
64308   if (!arg2) {
64309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64310     return 0;
64311   }
64312   {
64313     try {
64314       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
64315     } catch (std::out_of_range& e) {
64316       {
64317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64318       };
64319     } catch (std::exception& e) {
64320       {
64321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64322       };
64323     } catch (Dali::DaliException e) {
64324       {
64325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64326       };
64327     } catch (...) {
64328       {
64329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64330       };
64331     }
64332   }
64333
64334   jresult = result;
64335   return jresult;
64336 }
64337
64338
64339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
64340   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64341   int arg2 ;
64342   SwigDirector_ViewImpl *darg = 0;
64343
64344   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64345   arg2 = (int)jarg2;
64346   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64347   {
64348     try {
64349       if(darg) {
64350         (darg)->OnStageConnection(arg2);
64351       }
64352     } catch (std::out_of_range& e) {
64353       {
64354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64355       };
64356     } catch (std::exception& e) {
64357       {
64358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64359       };
64360     } catch (Dali::DaliException e) {
64361       {
64362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64363       };
64364     } catch (...) {
64365       {
64366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64367       };
64368     }
64369   }
64370
64371 }
64372
64373
64374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
64375   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64376   int arg2 ;
64377   SwigDirector_ViewImpl *darg = 0;
64378
64379   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64380   arg2 = (int)jarg2;
64381   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64382   {
64383     try {
64384       if(darg) {
64385         (darg)->OnStageConnectionSwigPublic(arg2);
64386       }
64387     } catch (std::out_of_range& e) {
64388       {
64389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64390       };
64391     } catch (std::exception& e) {
64392       {
64393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64394       };
64395     } catch (Dali::DaliException e) {
64396       {
64397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64398       };
64399     } catch (...) {
64400       {
64401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64402       };
64403     }
64404   }
64405
64406 }
64407
64408
64409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
64410   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64411   SwigDirector_ViewImpl *darg = 0;
64412
64413   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64414   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64415   {
64416     try {
64417       if(darg) {
64418         (darg)->OnStageDisconnection();
64419       }
64420     } catch (std::out_of_range& e) {
64421       {
64422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64423       };
64424     } catch (std::exception& e) {
64425       {
64426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64427       };
64428     } catch (Dali::DaliException e) {
64429       {
64430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64431       };
64432     } catch (...) {
64433       {
64434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64435       };
64436     }
64437   }
64438
64439 }
64440
64441
64442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
64443   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64444   SwigDirector_ViewImpl *darg = 0;
64445
64446   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64447   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64448   {
64449     try {
64450       if(darg) {
64451         (darg)->OnStageDisconnectionSwigPublic();
64452       }
64453     } catch (std::out_of_range& e) {
64454       {
64455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64456       };
64457     } catch (std::exception& e) {
64458       {
64459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64460       };
64461     } catch (Dali::DaliException e) {
64462       {
64463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64464       };
64465     } catch (...) {
64466       {
64467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64468       };
64469     }
64470   }
64471
64472 }
64473
64474
64475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
64476   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64477   Dali::Actor *arg2 = 0 ;
64478   SwigDirector_ViewImpl *darg = 0;
64479
64480   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64481   arg2 = (Dali::Actor *)jarg2;
64482   if (!arg2) {
64483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64484     return ;
64485   }
64486   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64487   {
64488     try {
64489       if(darg) {
64490         (darg)->OnChildAdd(*arg2);
64491       }
64492     } catch (std::out_of_range& e) {
64493       {
64494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64495       };
64496     } catch (std::exception& e) {
64497       {
64498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64499       };
64500     } catch (Dali::DaliException e) {
64501       {
64502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64503       };
64504     } catch (...) {
64505       {
64506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64507       };
64508     }
64509   }
64510
64511 }
64512
64513
64514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64515   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64516   Dali::Actor *arg2 = 0 ;
64517   SwigDirector_ViewImpl *darg = 0;
64518
64519   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64520   arg2 = (Dali::Actor *)jarg2;
64521   if (!arg2) {
64522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64523     return ;
64524   }
64525   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64526   {
64527     try {
64528       if(darg) {
64529           (darg)->OnChildAddSwigPublic(*arg2);
64530       }
64531     } catch (std::out_of_range& e) {
64532       {
64533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64534       };
64535     } catch (std::exception& e) {
64536       {
64537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64538       };
64539     } catch (Dali::DaliException e) {
64540       {
64541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64542       };
64543     } catch (...) {
64544       {
64545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64546       };
64547     }
64548   }
64549
64550 }
64551
64552
64553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64554   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64555   Dali::Actor *arg2 = 0 ;
64556   SwigDirector_ViewImpl *darg = 0;
64557
64558   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64559   arg2 = (Dali::Actor *)jarg2;
64560   if (!arg2) {
64561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64562     return ;
64563   }
64564   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64565   {
64566     try {
64567       if(darg) {
64568         (darg)->OnChildRemove(*arg2);
64569       }
64570     } catch (std::out_of_range& e) {
64571       {
64572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64573       };
64574     } catch (std::exception& e) {
64575       {
64576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64577       };
64578     } catch (Dali::DaliException e) {
64579       {
64580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64581       };
64582     } catch (...) {
64583       {
64584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64585       };
64586     }
64587   }
64588
64589 }
64590
64591
64592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64593   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64594   Dali::Actor *arg2 = 0 ;
64595   SwigDirector_ViewImpl *darg = 0;
64596
64597   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64598   arg2 = (Dali::Actor *)jarg2;
64599   if (!arg2) {
64600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64601     return ;
64602   }
64603   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64604   {
64605     try {
64606       if(darg) {
64607         (darg)->OnChildRemoveSwigPublic(*arg2);
64608       }
64609     } catch (std::out_of_range& e) {
64610       {
64611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64612       };
64613     } catch (std::exception& e) {
64614       {
64615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64616       };
64617     } catch (Dali::DaliException e) {
64618       {
64619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64620       };
64621     } catch (...) {
64622       {
64623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64624       };
64625     }
64626   }
64627
64628 }
64629
64630
64631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64632   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64633   Dali::Property::Index arg2 ;
64634   Dali::Property::Value arg3 ;
64635   Dali::Property::Value *argp3 ;
64636   SwigDirector_ViewImpl *darg = 0;
64637
64638   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64639   arg2 = (Dali::Property::Index)jarg2;
64640   argp3 = (Dali::Property::Value *)jarg3;
64641   if (!argp3) {
64642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64643     return ;
64644   }
64645   arg3 = *argp3;
64646   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64647   if (!darg) {
64648     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64649     return;
64650   }
64651   {
64652     try {
64653       (darg)->OnPropertySet(arg2,arg3);
64654     } catch (std::out_of_range& e) {
64655       {
64656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64657       };
64658     } catch (std::exception& e) {
64659       {
64660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64661       };
64662     } catch (Dali::DaliException e) {
64663       {
64664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64665       };
64666     } catch (...) {
64667       {
64668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64669       };
64670     }
64671   }
64672
64673 }
64674
64675
64676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64677   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64678   Dali::Property::Index arg2 ;
64679   Dali::Property::Value arg3 ;
64680   Dali::Property::Value *argp3 ;
64681   SwigDirector_ViewImpl *darg = 0;
64682
64683   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64684   arg2 = (Dali::Property::Index)jarg2;
64685   argp3 = (Dali::Property::Value *)jarg3;
64686   if (!argp3) {
64687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64688     return ;
64689   }
64690   arg3 = *argp3;
64691   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64692   if (!darg) {
64693     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64694     return;
64695   }
64696   {
64697     try {
64698       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64699     } catch (std::out_of_range& e) {
64700       {
64701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64702       };
64703     } catch (std::exception& e) {
64704       {
64705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64706       };
64707     } catch (Dali::DaliException e) {
64708       {
64709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64710       };
64711     } catch (...) {
64712       {
64713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64714       };
64715     }
64716   }
64717
64718 }
64719
64720
64721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64722   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64723   Dali::Vector3 *arg2 = 0 ;
64724   SwigDirector_ViewImpl *darg = 0;
64725
64726   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64727   arg2 = (Dali::Vector3 *)jarg2;
64728   if (!arg2) {
64729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64730     return ;
64731   }
64732   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64733   if (!darg) {
64734     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64735     return;
64736   }
64737   {
64738     try {
64739       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64740     } catch (std::out_of_range& e) {
64741       {
64742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64743       };
64744     } catch (std::exception& e) {
64745       {
64746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64747       };
64748     } catch (Dali::DaliException e) {
64749       {
64750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64751       };
64752     } catch (...) {
64753       {
64754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64755       };
64756     }
64757   }
64758
64759 }
64760
64761
64762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64763   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64764   Dali::Vector3 *arg2 = 0 ;
64765   SwigDirector_ViewImpl *darg = 0;
64766
64767   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64768   arg2 = (Dali::Vector3 *)jarg2;
64769   if (!arg2) {
64770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64771     return ;
64772   }
64773   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64774   if (!darg) {
64775     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64776     return;
64777   }
64778   {
64779     try {
64780       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64781     } catch (std::out_of_range& e) {
64782       {
64783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64784       };
64785     } catch (std::exception& e) {
64786       {
64787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64788       };
64789     } catch (Dali::DaliException e) {
64790       {
64791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64792       };
64793     } catch (...) {
64794       {
64795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64796       };
64797     }
64798   }
64799
64800 }
64801
64802
64803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64804   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64805   Dali::Animation *arg2 = 0 ;
64806   Dali::Vector3 *arg3 = 0 ;
64807   SwigDirector_ViewImpl *darg = 0;
64808
64809   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64810   arg2 = (Dali::Animation *)jarg2;
64811   if (!arg2) {
64812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64813     return ;
64814   }
64815   arg3 = (Dali::Vector3 *)jarg3;
64816   if (!arg3) {
64817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64818     return ;
64819   }
64820   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64821   if (!darg) {
64822     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64823     return;
64824   }
64825   {
64826     try {
64827       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64828     } catch (std::out_of_range& e) {
64829       {
64830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64831       };
64832     } catch (std::exception& e) {
64833       {
64834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64835       };
64836     } catch (Dali::DaliException e) {
64837       {
64838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64839       };
64840     } catch (...) {
64841       {
64842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64843       };
64844     }
64845   }
64846
64847 }
64848
64849
64850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64851   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64852   Dali::Animation *arg2 = 0 ;
64853   Dali::Vector3 *arg3 = 0 ;
64854   SwigDirector_ViewImpl *darg = 0;
64855
64856   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64857   arg2 = (Dali::Animation *)jarg2;
64858   if (!arg2) {
64859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64860     return ;
64861   }
64862   arg3 = (Dali::Vector3 *)jarg3;
64863   if (!arg3) {
64864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64865     return ;
64866   }
64867   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64868   if (!darg) {
64869     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64870     return;
64871   }
64872   {
64873     try {
64874       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64875     } catch (std::out_of_range& e) {
64876       {
64877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64878       };
64879     } catch (std::exception& e) {
64880       {
64881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64882       };
64883     } catch (Dali::DaliException e) {
64884       {
64885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64886       };
64887     } catch (...) {
64888       {
64889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64890       };
64891     }
64892   }
64893
64894 }
64895
64896
64897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64898   unsigned int jresult ;
64899   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64900   Dali::TouchEvent *arg2 = 0 ;
64901   SwigDirector_ViewImpl *darg = 0;
64902   bool result;
64903
64904   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64905   arg2 = (Dali::TouchEvent *)jarg2;
64906   if (!arg2) {
64907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64908     return 0;
64909   }
64910   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64911   if (!darg) {
64912     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64913     return 0;
64914   }
64915   {
64916     try {
64917       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64918     } catch (std::out_of_range& e) {
64919       {
64920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64921       };
64922     } catch (std::exception& e) {
64923       {
64924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64925       };
64926     } catch (Dali::DaliException e) {
64927       {
64928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64929       };
64930     } catch (...) {
64931       {
64932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64933       };
64934     }
64935   }
64936
64937   jresult = result;
64938   return jresult;
64939 }
64940
64941
64942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64943   unsigned int jresult ;
64944   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64945   Dali::TouchEvent *arg2 = 0 ;
64946   SwigDirector_ViewImpl *darg = 0;
64947   bool result;
64948
64949   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64950   arg2 = (Dali::TouchEvent *)jarg2;
64951   if (!arg2) {
64952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64953     return 0;
64954   }
64955   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64956   if (!darg) {
64957     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64958     return 0;
64959   }
64960   {
64961     try {
64962       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64963     } catch (std::out_of_range& e) {
64964       {
64965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64966       };
64967     } catch (std::exception& e) {
64968       {
64969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64970       };
64971     } catch (Dali::DaliException e) {
64972       {
64973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64974       };
64975     } catch (...) {
64976       {
64977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64978       };
64979     }
64980   }
64981
64982   jresult = result;
64983   return jresult;
64984 }
64985
64986
64987 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64988   unsigned int jresult ;
64989   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64990   Dali::HoverEvent *arg2 = 0 ;
64991   SwigDirector_ViewImpl *darg = 0;
64992   bool result;
64993
64994   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64995   arg2 = (Dali::HoverEvent *)jarg2;
64996   if (!arg2) {
64997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64998     return 0;
64999   }
65000   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65001   if (!darg) {
65002     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65003     return 0;
65004   }
65005   {
65006     try {
65007       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
65008     } catch (std::out_of_range& e) {
65009       {
65010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65011       };
65012     } catch (std::exception& e) {
65013       {
65014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65015       };
65016     } catch (Dali::DaliException e) {
65017       {
65018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65019       };
65020     } catch (...) {
65021       {
65022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65023       };
65024     }
65025   }
65026
65027   jresult = result;
65028   return jresult;
65029 }
65030
65031
65032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65033   unsigned int jresult ;
65034   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65035   Dali::HoverEvent *arg2 = 0 ;
65036   SwigDirector_ViewImpl *darg = 0;
65037   bool result;
65038
65039   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65040   arg2 = (Dali::HoverEvent *)jarg2;
65041   if (!arg2) {
65042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
65043     return 0;
65044   }
65045   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65046   if (!darg) {
65047     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65048     return 0;
65049   }
65050   {
65051     try {
65052       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
65053     } catch (std::out_of_range& e) {
65054       {
65055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65056       };
65057     } catch (std::exception& e) {
65058       {
65059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65060       };
65061     } catch (Dali::DaliException e) {
65062       {
65063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65064       };
65065     } catch (...) {
65066       {
65067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65068       };
65069     }
65070   }
65071
65072   jresult = result;
65073   return jresult;
65074 }
65075
65076
65077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
65078   unsigned int jresult ;
65079   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65080   Dali::KeyEvent *arg2 = 0 ;
65081   SwigDirector_ViewImpl *darg = 0;
65082   bool result;
65083
65084   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65085   arg2 = (Dali::KeyEvent *)jarg2;
65086   if (!arg2) {
65087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
65088     return 0;
65089   }
65090   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65091   if (!darg) {
65092     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65093     return 0;
65094   }
65095   {
65096     try {
65097       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
65098     } catch (std::out_of_range& e) {
65099       {
65100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65101       };
65102     } catch (std::exception& e) {
65103       {
65104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65105       };
65106     } catch (Dali::DaliException e) {
65107       {
65108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65109       };
65110     } catch (...) {
65111       {
65112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65113       };
65114     }
65115   }
65116
65117   jresult = result;
65118   return jresult;
65119 }
65120
65121
65122 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65123   unsigned int jresult ;
65124   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65125   Dali::KeyEvent *arg2 = 0 ;
65126   SwigDirector_ViewImpl *darg = 0;
65127   bool result;
65128
65129   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65130   arg2 = (Dali::KeyEvent *)jarg2;
65131   if (!arg2) {
65132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
65133     return 0;
65134   }
65135   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65136   if (!darg) {
65137     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65138     return 0;
65139   }
65140   {
65141     try {
65142       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
65143     } catch (std::out_of_range& e) {
65144       {
65145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65146       };
65147     } catch (std::exception& e) {
65148       {
65149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65150       };
65151     } catch (Dali::DaliException e) {
65152       {
65153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65154       };
65155     } catch (...) {
65156       {
65157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65158       };
65159     }
65160   }
65161
65162   jresult = result;
65163   return jresult;
65164 }
65165
65166
65167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
65168   unsigned int jresult ;
65169   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65170   Dali::WheelEvent *arg2 = 0 ;
65171   SwigDirector_ViewImpl *darg = 0;
65172   bool result;
65173
65174   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65175   arg2 = (Dali::WheelEvent *)jarg2;
65176   if (!arg2) {
65177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65178     return 0;
65179   }
65180   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65181   if (!darg) {
65182     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65183     return 0;
65184   }
65185   {
65186     try {
65187       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
65188     } catch (std::out_of_range& e) {
65189       {
65190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65191       };
65192     } catch (std::exception& e) {
65193       {
65194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65195       };
65196     } catch (Dali::DaliException e) {
65197       {
65198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65199       };
65200     } catch (...) {
65201       {
65202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65203       };
65204     }
65205   }
65206
65207   jresult = result;
65208   return jresult;
65209 }
65210
65211
65212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65213   unsigned int jresult ;
65214   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65215   Dali::WheelEvent *arg2 = 0 ;
65216   SwigDirector_ViewImpl *darg = 0;
65217   bool result;
65218
65219   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65220   arg2 = (Dali::WheelEvent *)jarg2;
65221   if (!arg2) {
65222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65223     return 0;
65224   }
65225   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65226   if (!darg) {
65227     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65228     return 0;
65229   }
65230   {
65231     try {
65232       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
65233     } catch (std::out_of_range& e) {
65234       {
65235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65236       };
65237     } catch (std::exception& e) {
65238       {
65239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65240       };
65241     } catch (Dali::DaliException e) {
65242       {
65243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65244       };
65245     } catch (...) {
65246       {
65247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65248       };
65249     }
65250   }
65251
65252   jresult = result;
65253   return jresult;
65254 }
65255
65256
65257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
65258   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65259   Dali::Vector2 *arg2 = 0 ;
65260   Dali::RelayoutContainer *arg3 = 0 ;
65261   SwigDirector_ViewImpl *darg = 0;
65262
65263   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65264   arg2 = (Dali::Vector2 *)jarg2;
65265   if (!arg2) {
65266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65267     return ;
65268   }
65269   arg3 = (Dali::RelayoutContainer *)jarg3;
65270   if (!arg3) {
65271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65272     return ;
65273   }
65274   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65275   if (!darg) {
65276     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65277     return;
65278   }
65279   {
65280     try {
65281       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
65282     } catch (std::out_of_range& e) {
65283       {
65284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65285       };
65286     } catch (std::exception& e) {
65287       {
65288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65289       };
65290     } catch (Dali::DaliException e) {
65291       {
65292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65293       };
65294     } catch (...) {
65295       {
65296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65297       };
65298     }
65299   }
65300
65301 }
65302
65303
65304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
65305   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65306   Dali::Vector2 *arg2 = 0 ;
65307   Dali::RelayoutContainer *arg3 = 0 ;
65308   SwigDirector_ViewImpl *darg = 0;
65309
65310   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65311   arg2 = (Dali::Vector2 *)jarg2;
65312   if (!arg2) {
65313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65314     return ;
65315   }
65316   arg3 = (Dali::RelayoutContainer *)jarg3;
65317   if (!arg3) {
65318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65319     return ;
65320   }
65321   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65322   if (!darg) {
65323     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65324     return;
65325   }
65326   {
65327     try {
65328       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
65329     } catch (std::out_of_range& e) {
65330       {
65331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65332       };
65333     } catch (std::exception& e) {
65334       {
65335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65336       };
65337     } catch (Dali::DaliException e) {
65338       {
65339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65340       };
65341     } catch (...) {
65342       {
65343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65344       };
65345     }
65346   }
65347
65348 }
65349
65350
65351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
65352   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65353   Dali::ResizePolicy::Type arg2 ;
65354   Dali::Dimension::Type arg3 ;
65355   SwigDirector_ViewImpl *darg = 0;
65356
65357   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65358   arg2 = (Dali::ResizePolicy::Type)jarg2;
65359   arg3 = (Dali::Dimension::Type)jarg3;
65360   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65361   if (!darg) {
65362     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65363     return;
65364   }
65365   {
65366     try {
65367       (darg)->OnSetResizePolicy(arg2,arg3);
65368     } catch (std::out_of_range& e) {
65369       {
65370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65371       };
65372     } catch (std::exception& e) {
65373       {
65374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65375       };
65376     } catch (Dali::DaliException e) {
65377       {
65378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65379       };
65380     } catch (...) {
65381       {
65382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65383       };
65384     }
65385   }
65386
65387 }
65388
65389
65390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
65391   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65392   Dali::ResizePolicy::Type arg2 ;
65393   Dali::Dimension::Type arg3 ;
65394   SwigDirector_ViewImpl *darg = 0;
65395
65396   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65397   arg2 = (Dali::ResizePolicy::Type)jarg2;
65398   arg3 = (Dali::Dimension::Type)jarg3;
65399   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65400   if (!darg) {
65401     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65402     return;
65403   }
65404   {
65405     try {
65406       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
65407     } catch (std::out_of_range& e) {
65408       {
65409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65410       };
65411     } catch (std::exception& e) {
65412       {
65413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65414       };
65415     } catch (Dali::DaliException e) {
65416       {
65417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65418       };
65419     } catch (...) {
65420       {
65421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65422       };
65423     }
65424   }
65425
65426 }
65427
65428
65429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
65430   void * jresult ;
65431   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65432   SwigDirector_ViewImpl *darg = 0;
65433   Dali::Vector3 result;
65434
65435   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
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 0;
65440   }
65441   {
65442     try {
65443       result = (darg)->GetNaturalSize();
65444     } catch (std::out_of_range& e) {
65445       {
65446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65447       };
65448     } catch (std::exception& e) {
65449       {
65450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65451       };
65452     } catch (Dali::DaliException e) {
65453       {
65454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65455       };
65456     } catch (...) {
65457       {
65458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65459       };
65460     }
65461   }
65462
65463   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65464   return jresult;
65465 }
65466
65467
65468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
65469   void * jresult ;
65470   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65471   SwigDirector_ViewImpl *darg = 0;
65472   Dali::Vector3 result;
65473
65474   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65475   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65476   if (!darg) {
65477     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65478     return 0;
65479   }
65480   {
65481     try {
65482       result = (darg)->GetNaturalSizeSwigPublic();
65483     } catch (std::out_of_range& e) {
65484       {
65485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65486       };
65487     } catch (std::exception& e) {
65488       {
65489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65490       };
65491     } catch (Dali::DaliException e) {
65492       {
65493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65494       };
65495     } catch (...) {
65496       {
65497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65498       };
65499     }
65500   }
65501
65502   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65503   return jresult;
65504 }
65505
65506
65507 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
65508   float jresult ;
65509   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65510   Dali::Actor *arg2 = 0 ;
65511   Dali::Dimension::Type arg3 ;
65512   SwigDirector_ViewImpl *darg = 0;
65513   float result;
65514
65515   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65516   arg2 = (Dali::Actor *)jarg2;
65517   if (!arg2) {
65518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65519     return 0;
65520   }
65521   arg3 = (Dali::Dimension::Type)jarg3;
65522   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65523   if (!darg) {
65524     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65525     return 0;
65526   }
65527   {
65528     try {
65529       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65530     } catch (std::out_of_range& e) {
65531       {
65532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65533       };
65534     } catch (std::exception& e) {
65535       {
65536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65537       };
65538     } catch (Dali::DaliException e) {
65539       {
65540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65541       };
65542     } catch (...) {
65543       {
65544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65545       };
65546     }
65547   }
65548
65549   jresult = result;
65550   return jresult;
65551 }
65552
65553
65554 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65555   float jresult ;
65556   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65557   Dali::Actor *arg2 = 0 ;
65558   Dali::Dimension::Type arg3 ;
65559   SwigDirector_ViewImpl *darg = 0;
65560   float result;
65561
65562   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65563   arg2 = (Dali::Actor *)jarg2;
65564   if (!arg2) {
65565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65566     return 0;
65567   }
65568   arg3 = (Dali::Dimension::Type)jarg3;
65569   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65570   if (!darg) {
65571     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65572     return 0;
65573   }
65574   {
65575     try {
65576       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65577     } catch (std::out_of_range& e) {
65578       {
65579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65580       };
65581     } catch (std::exception& e) {
65582       {
65583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65584       };
65585     } catch (Dali::DaliException e) {
65586       {
65587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65588       };
65589     } catch (...) {
65590       {
65591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65592       };
65593     }
65594   }
65595
65596   jresult = result;
65597   return jresult;
65598 }
65599
65600
65601 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65602   float jresult ;
65603   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65604   float arg2 ;
65605   SwigDirector_ViewImpl *darg = 0;
65606   float result;
65607
65608   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65609   arg2 = (float)jarg2;
65610   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65611   if (!darg) {
65612     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65613     return 0;
65614   }
65615   {
65616     try {
65617       result = (float)(darg)->GetHeightForWidth(arg2);
65618     } catch (std::out_of_range& e) {
65619       {
65620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65621       };
65622     } catch (std::exception& e) {
65623       {
65624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65625       };
65626     } catch (Dali::DaliException e) {
65627       {
65628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65629       };
65630     } catch (...) {
65631       {
65632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65633       };
65634     }
65635   }
65636
65637   jresult = result;
65638   return jresult;
65639 }
65640
65641
65642 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65643   float jresult ;
65644   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65645   float arg2 ;
65646   SwigDirector_ViewImpl *darg = 0;
65647   float result;
65648
65649   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65650   arg2 = (float)jarg2;
65651   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65652   if (!darg) {
65653     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65654     return 0;
65655   }
65656   {
65657     try {
65658       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65659     } catch (std::out_of_range& e) {
65660       {
65661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65662       };
65663     } catch (std::exception& e) {
65664       {
65665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65666       };
65667     } catch (Dali::DaliException e) {
65668       {
65669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65670       };
65671     } catch (...) {
65672       {
65673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65674       };
65675     }
65676   }
65677
65678   jresult = result;
65679   return jresult;
65680 }
65681
65682
65683 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65684   float jresult ;
65685   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65686   float arg2 ;
65687   SwigDirector_ViewImpl *darg = 0;
65688   float result;
65689
65690   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65691   arg2 = (float)jarg2;
65692   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65693   if (!darg) {
65694     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65695     return 0;
65696   }
65697   {
65698     try {
65699       result = (float)(darg)->GetWidthForHeight(arg2);
65700     } catch (std::out_of_range& e) {
65701       {
65702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65703       };
65704     } catch (std::exception& e) {
65705       {
65706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65707       };
65708     } catch (Dali::DaliException e) {
65709       {
65710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65711       };
65712     } catch (...) {
65713       {
65714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65715       };
65716     }
65717   }
65718
65719   jresult = result;
65720   return jresult;
65721 }
65722
65723
65724 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65725   float jresult ;
65726   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65727   float arg2 ;
65728   SwigDirector_ViewImpl *darg = 0;
65729   float result;
65730
65731   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65732   arg2 = (float)jarg2;
65733   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65734   if (!darg) {
65735     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65736     return 0;
65737   }
65738   {
65739     try {
65740       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65741     } catch (std::out_of_range& e) {
65742       {
65743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65744       };
65745     } catch (std::exception& e) {
65746       {
65747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65748       };
65749     } catch (Dali::DaliException e) {
65750       {
65751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65752       };
65753     } catch (...) {
65754       {
65755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65756       };
65757     }
65758   }
65759
65760   jresult = result;
65761   return jresult;
65762 }
65763
65764
65765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65766   unsigned int jresult ;
65767   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65768   Dali::Dimension::Type arg2 ;
65769   SwigDirector_ViewImpl *darg = 0;
65770   bool result;
65771
65772   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65773   arg2 = (Dali::Dimension::Type)jarg2;
65774   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65775   if (!darg) {
65776     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65777     return 0;
65778   }
65779   {
65780     try {
65781       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65782     } catch (std::out_of_range& e) {
65783       {
65784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65785       };
65786     } catch (std::exception& e) {
65787       {
65788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65789       };
65790     } catch (Dali::DaliException e) {
65791       {
65792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65793       };
65794     } catch (...) {
65795       {
65796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65797       };
65798     }
65799   }
65800
65801   jresult = result;
65802   return jresult;
65803 }
65804
65805
65806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65807   unsigned int jresult ;
65808   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65809   Dali::Dimension::Type arg2 ;
65810   SwigDirector_ViewImpl *darg = 0;
65811   bool result;
65812
65813   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65814   arg2 = (Dali::Dimension::Type)jarg2;
65815   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65816   if (!darg) {
65817     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65818     return 0;
65819   }
65820   {
65821     try {
65822       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65823     } catch (std::out_of_range& e) {
65824       {
65825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65826       };
65827     } catch (std::exception& e) {
65828       {
65829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65830       };
65831     } catch (Dali::DaliException e) {
65832       {
65833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65834       };
65835     } catch (...) {
65836       {
65837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65838       };
65839     }
65840   }
65841
65842   jresult = result;
65843   return jresult;
65844 }
65845
65846
65847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65848   unsigned int jresult ;
65849   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65850   SwigDirector_ViewImpl *darg = 0;
65851   bool result;
65852
65853   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65854   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65855   if (!darg) {
65856     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65857     return 0;
65858   }
65859   {
65860     try {
65861       result = (bool)(darg)->RelayoutDependentOnChildren();
65862     } catch (std::out_of_range& e) {
65863       {
65864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65865       };
65866     } catch (std::exception& e) {
65867       {
65868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65869       };
65870     } catch (Dali::DaliException e) {
65871       {
65872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65873       };
65874     } catch (...) {
65875       {
65876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65877       };
65878     }
65879   }
65880
65881   jresult = result;
65882   return jresult;
65883 }
65884
65885
65886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65887   unsigned int jresult ;
65888   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65889   SwigDirector_ViewImpl *darg = 0;
65890   bool result;
65891
65892   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65893   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65894   if (!darg) {
65895     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65896     return 0;
65897   }
65898   {
65899     try {
65900       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65901     } catch (std::out_of_range& e) {
65902       {
65903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65904       };
65905     } catch (std::exception& e) {
65906       {
65907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65908       };
65909     } catch (Dali::DaliException e) {
65910       {
65911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65912       };
65913     } catch (...) {
65914       {
65915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65916       };
65917     }
65918   }
65919
65920   jresult = result;
65921   return jresult;
65922 }
65923
65924
65925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65926   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65927   Dali::Dimension::Type arg2 ;
65928   SwigDirector_ViewImpl *darg = 0;
65929
65930   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65931   arg2 = (Dali::Dimension::Type)jarg2;
65932   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65933   if (!darg) {
65934     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65935     return;
65936   }
65937   {
65938     try {
65939       (darg)->OnCalculateRelayoutSize(arg2);
65940     } catch (std::out_of_range& e) {
65941       {
65942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65943       };
65944     } catch (std::exception& e) {
65945       {
65946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65947       };
65948     } catch (Dali::DaliException e) {
65949       {
65950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65951       };
65952     } catch (...) {
65953       {
65954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65955       };
65956     }
65957   }
65958
65959 }
65960
65961
65962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(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)->OnCalculateRelayoutSizeSwigPublic(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_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
66000   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66001   float arg2 ;
66002   Dali::Dimension::Type arg3 ;
66003   SwigDirector_ViewImpl *darg = 0;
66004
66005   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66006   arg2 = (float)jarg2;
66007   arg3 = (Dali::Dimension::Type)jarg3;
66008   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
66009   if (!darg) {
66010     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
66011     return;
66012   }
66013   {
66014     try {
66015       (darg)->OnLayoutNegotiated(arg2,arg3);
66016     } catch (std::out_of_range& e) {
66017       {
66018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66019       };
66020     } catch (std::exception& e) {
66021       {
66022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66023       };
66024     } catch (Dali::DaliException e) {
66025       {
66026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66027       };
66028     } catch (...) {
66029       {
66030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66031       };
66032     }
66033   }
66034
66035 }
66036
66037
66038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
66039   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66040   float arg2 ;
66041   Dali::Dimension::Type arg3 ;
66042   SwigDirector_ViewImpl *darg = 0;
66043
66044   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66045   arg2 = (float)jarg2;
66046   arg3 = (Dali::Dimension::Type)jarg3;
66047   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
66048   if (!darg) {
66049     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
66050     return;
66051   }
66052   {
66053     try {
66054       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
66055     } catch (std::out_of_range& e) {
66056       {
66057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66058       };
66059     } catch (std::exception& e) {
66060       {
66061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66062       };
66063     } catch (Dali::DaliException e) {
66064       {
66065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66066       };
66067     } catch (...) {
66068       {
66069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66070       };
66071     }
66072   }
66073
66074 }
66075
66076
66077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
66078   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66079
66080   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66081   {
66082     try {
66083       (arg1)->OnInitialize();
66084     } catch (std::out_of_range& e) {
66085       {
66086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66087       };
66088     } catch (std::exception& e) {
66089       {
66090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66091       };
66092     } catch (Dali::DaliException e) {
66093       {
66094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66095       };
66096     } catch (...) {
66097       {
66098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66099       };
66100     }
66101   }
66102
66103 }
66104
66105
66106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
66107   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66108
66109   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66110   {
66111     try {
66112       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
66113     } catch (std::out_of_range& e) {
66114       {
66115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66116       };
66117     } catch (std::exception& e) {
66118       {
66119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66120       };
66121     } catch (Dali::DaliException e) {
66122       {
66123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66124       };
66125     } catch (...) {
66126       {
66127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66128       };
66129     }
66130   }
66131
66132 }
66133
66134
66135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
66136   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66137   Dali::Actor *arg2 = 0 ;
66138
66139   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66140   arg2 = (Dali::Actor *)jarg2;
66141   if (!arg2) {
66142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66143     return ;
66144   }
66145   {
66146     try {
66147       (arg1)->OnControlChildAdd(*arg2);
66148     } catch (std::out_of_range& e) {
66149       {
66150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66151       };
66152     } catch (std::exception& e) {
66153       {
66154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66155       };
66156     } catch (Dali::DaliException e) {
66157       {
66158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66159       };
66160     } catch (...) {
66161       {
66162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66163       };
66164     }
66165   }
66166
66167 }
66168
66169
66170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66171   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66172   Dali::Actor *arg2 = 0 ;
66173
66174   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66175   arg2 = (Dali::Actor *)jarg2;
66176   if (!arg2) {
66177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66178     return ;
66179   }
66180   {
66181     try {
66182       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
66183     } catch (std::out_of_range& e) {
66184       {
66185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66186       };
66187     } catch (std::exception& e) {
66188       {
66189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66190       };
66191     } catch (Dali::DaliException e) {
66192       {
66193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66194       };
66195     } catch (...) {
66196       {
66197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66198       };
66199     }
66200   }
66201
66202 }
66203
66204
66205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
66206   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66207   Dali::Actor *arg2 = 0 ;
66208
66209   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66210   arg2 = (Dali::Actor *)jarg2;
66211   if (!arg2) {
66212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66213     return ;
66214   }
66215   {
66216     try {
66217       (arg1)->OnControlChildRemove(*arg2);
66218     } catch (std::out_of_range& e) {
66219       {
66220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66221       };
66222     } catch (std::exception& e) {
66223       {
66224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66225       };
66226     } catch (Dali::DaliException e) {
66227       {
66228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66229       };
66230     } catch (...) {
66231       {
66232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66233       };
66234     }
66235   }
66236
66237 }
66238
66239
66240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66241   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66242   Dali::Actor *arg2 = 0 ;
66243
66244   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66245   arg2 = (Dali::Actor *)jarg2;
66246   if (!arg2) {
66247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66248     return ;
66249   }
66250   {
66251     try {
66252       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
66253     } catch (std::out_of_range& e) {
66254       {
66255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66256       };
66257     } catch (std::exception& e) {
66258       {
66259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66260       };
66261     } catch (Dali::DaliException e) {
66262       {
66263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66264       };
66265     } catch (...) {
66266       {
66267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66268       };
66269     }
66270   }
66271
66272 }
66273
66274
66275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
66276   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66277   Dali::Toolkit::StyleManager arg2 ;
66278   Dali::StyleChange::Type arg3 ;
66279   Dali::Toolkit::StyleManager *argp2 ;
66280
66281   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66282   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66283   if (!argp2) {
66284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66285     return ;
66286   }
66287   arg2 = *argp2;
66288   arg3 = (Dali::StyleChange::Type)jarg3;
66289   {
66290     try {
66291       (arg1)->OnStyleChange(arg2,arg3);
66292     } catch (std::out_of_range& e) {
66293       {
66294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66295       };
66296     } catch (std::exception& e) {
66297       {
66298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66299       };
66300     } catch (Dali::DaliException e) {
66301       {
66302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66303       };
66304     } catch (...) {
66305       {
66306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66307       };
66308     }
66309   }
66310
66311 }
66312
66313
66314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
66315   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66316   Dali::Toolkit::StyleManager arg2 ;
66317   Dali::StyleChange::Type arg3 ;
66318   Dali::Toolkit::StyleManager *argp2 ;
66319
66320   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66321   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66322   if (!argp2) {
66323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66324     return ;
66325   }
66326   arg2 = *argp2;
66327   arg3 = (Dali::StyleChange::Type)jarg3;
66328   {
66329     try {
66330       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
66331     } catch (std::out_of_range& e) {
66332       {
66333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66334       };
66335     } catch (std::exception& e) {
66336       {
66337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66338       };
66339     } catch (Dali::DaliException e) {
66340       {
66341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66342       };
66343     } catch (...) {
66344       {
66345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66346       };
66347     }
66348   }
66349
66350 }
66351
66352
66353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
66354   unsigned int jresult ;
66355   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66356   bool result;
66357
66358   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66359   {
66360     try {
66361       result = (bool)(arg1)->OnAccessibilityActivated();
66362     } catch (std::out_of_range& e) {
66363       {
66364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66365       };
66366     } catch (std::exception& e) {
66367       {
66368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66369       };
66370     } catch (Dali::DaliException e) {
66371       {
66372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66373       };
66374     } catch (...) {
66375       {
66376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66377       };
66378     }
66379   }
66380
66381   jresult = result;
66382   return jresult;
66383 }
66384
66385
66386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
66387   unsigned int jresult ;
66388   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66389   bool result;
66390
66391   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66392   {
66393     try {
66394       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
66395     } catch (std::out_of_range& e) {
66396       {
66397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66398       };
66399     } catch (std::exception& e) {
66400       {
66401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66402       };
66403     } catch (Dali::DaliException e) {
66404       {
66405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66406       };
66407     } catch (...) {
66408       {
66409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66410       };
66411     }
66412   }
66413
66414   jresult = result;
66415   return jresult;
66416 }
66417
66418
66419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
66420   unsigned int jresult ;
66421   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66422   Dali::PanGesture arg2 ;
66423   Dali::PanGesture *argp2 ;
66424   bool result;
66425
66426   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66427   argp2 = (Dali::PanGesture *)jarg2;
66428   if (!argp2) {
66429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66430     return 0;
66431   }
66432   arg2 = *argp2;
66433   {
66434     try {
66435       result = (bool)(arg1)->OnAccessibilityPan(arg2);
66436     } catch (std::out_of_range& e) {
66437       {
66438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66439       };
66440     } catch (std::exception& e) {
66441       {
66442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66443       };
66444     } catch (Dali::DaliException e) {
66445       {
66446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66447       };
66448     } catch (...) {
66449       {
66450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66451       };
66452     }
66453   }
66454
66455   jresult = result;
66456   return jresult;
66457 }
66458
66459
66460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66461   unsigned int jresult ;
66462   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66463   Dali::PanGesture arg2 ;
66464   Dali::PanGesture *argp2 ;
66465   bool result;
66466
66467   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66468   argp2 = (Dali::PanGesture *)jarg2;
66469   if (!argp2) {
66470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66471     return 0;
66472   }
66473   arg2 = *argp2;
66474   {
66475     try {
66476       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
66477     } catch (std::out_of_range& e) {
66478       {
66479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66480       };
66481     } catch (std::exception& e) {
66482       {
66483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66484       };
66485     } catch (Dali::DaliException e) {
66486       {
66487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66488       };
66489     } catch (...) {
66490       {
66491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66492       };
66493     }
66494   }
66495
66496   jresult = result;
66497   return jresult;
66498 }
66499
66500
66501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
66502   unsigned int jresult ;
66503   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66504   Dali::TouchEvent *arg2 = 0 ;
66505   bool result;
66506
66507   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66508   arg2 = (Dali::TouchEvent *)jarg2;
66509   if (!arg2) {
66510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66511     return 0;
66512   }
66513   {
66514     try {
66515       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66516     } catch (std::out_of_range& e) {
66517       {
66518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66519       };
66520     } catch (std::exception& e) {
66521       {
66522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66523       };
66524     } catch (Dali::DaliException e) {
66525       {
66526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66527       };
66528     } catch (...) {
66529       {
66530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66531       };
66532     }
66533   }
66534
66535   jresult = result;
66536   return jresult;
66537 }
66538
66539
66540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66541   unsigned int jresult ;
66542   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66543   Dali::TouchEvent *arg2 = 0 ;
66544   bool result;
66545
66546   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66547   arg2 = (Dali::TouchEvent *)jarg2;
66548   if (!arg2) {
66549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66550     return 0;
66551   }
66552   {
66553     try {
66554       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66555     } catch (std::out_of_range& e) {
66556       {
66557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66558       };
66559     } catch (std::exception& e) {
66560       {
66561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66562       };
66563     } catch (Dali::DaliException e) {
66564       {
66565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66566       };
66567     } catch (...) {
66568       {
66569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66570       };
66571     }
66572   }
66573
66574   jresult = result;
66575   return jresult;
66576 }
66577
66578
66579 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66580   unsigned int jresult ;
66581   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66582   bool arg2 ;
66583   bool result;
66584
66585   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66586   arg2 = jarg2 ? true : false;
66587   {
66588     try {
66589       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66590     } catch (std::out_of_range& e) {
66591       {
66592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66593       };
66594     } catch (std::exception& e) {
66595       {
66596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66597       };
66598     } catch (Dali::DaliException e) {
66599       {
66600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66601       };
66602     } catch (...) {
66603       {
66604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66605       };
66606     }
66607   }
66608
66609   jresult = result;
66610   return jresult;
66611 }
66612
66613
66614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66615   unsigned int jresult ;
66616   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66617   bool arg2 ;
66618   bool result;
66619
66620   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66621   arg2 = jarg2 ? true : false;
66622   {
66623     try {
66624       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66625     } catch (std::out_of_range& e) {
66626       {
66627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66628       };
66629     } catch (std::exception& e) {
66630       {
66631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66632       };
66633     } catch (Dali::DaliException e) {
66634       {
66635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66636       };
66637     } catch (...) {
66638       {
66639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66640       };
66641     }
66642   }
66643
66644   jresult = result;
66645   return jresult;
66646 }
66647
66648
66649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66650   unsigned int jresult ;
66651   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66652   bool result;
66653
66654   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66655   {
66656     try {
66657       result = (bool)(arg1)->OnAccessibilityZoom();
66658     } catch (std::out_of_range& e) {
66659       {
66660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66661       };
66662     } catch (std::exception& e) {
66663       {
66664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66665       };
66666     } catch (Dali::DaliException e) {
66667       {
66668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66669       };
66670     } catch (...) {
66671       {
66672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66673       };
66674     }
66675   }
66676
66677   jresult = result;
66678   return jresult;
66679 }
66680
66681
66682 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66683   unsigned int jresult ;
66684   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66685   bool result;
66686
66687   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66688   {
66689     try {
66690       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66691     } catch (std::out_of_range& e) {
66692       {
66693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66694       };
66695     } catch (std::exception& e) {
66696       {
66697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66698       };
66699     } catch (Dali::DaliException e) {
66700       {
66701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66702       };
66703     } catch (...) {
66704       {
66705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66706       };
66707     }
66708   }
66709
66710   jresult = result;
66711   return jresult;
66712 }
66713
66714
66715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66716   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66717
66718   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66719   {
66720     try {
66721       (arg1)->OnKeyInputFocusGained();
66722     } catch (std::out_of_range& e) {
66723       {
66724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66725       };
66726     } catch (std::exception& e) {
66727       {
66728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66729       };
66730     } catch (Dali::DaliException e) {
66731       {
66732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66733       };
66734     } catch (...) {
66735       {
66736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66737       };
66738     }
66739   }
66740
66741 }
66742
66743
66744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66745   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66746
66747   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66748   {
66749     try {
66750       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66751     } catch (std::out_of_range& e) {
66752       {
66753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66754       };
66755     } catch (std::exception& e) {
66756       {
66757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66758       };
66759     } catch (Dali::DaliException e) {
66760       {
66761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66762       };
66763     } catch (...) {
66764       {
66765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66766       };
66767     }
66768   }
66769
66770 }
66771
66772
66773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66774   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66775
66776   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66777   {
66778     try {
66779       (arg1)->OnKeyInputFocusLost();
66780     } catch (std::out_of_range& e) {
66781       {
66782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66783       };
66784     } catch (std::exception& e) {
66785       {
66786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66787       };
66788     } catch (Dali::DaliException e) {
66789       {
66790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66791       };
66792     } catch (...) {
66793       {
66794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66795       };
66796     }
66797   }
66798
66799 }
66800
66801
66802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66803   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66804
66805   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66806   {
66807     try {
66808       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66809     } catch (std::out_of_range& e) {
66810       {
66811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66812       };
66813     } catch (std::exception& e) {
66814       {
66815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66816       };
66817     } catch (Dali::DaliException e) {
66818       {
66819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66820       };
66821     } catch (...) {
66822       {
66823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66824       };
66825     }
66826   }
66827
66828 }
66829
66830
66831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66832   void * jresult ;
66833   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66834   Dali::Actor arg2 ;
66835   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66836   bool arg4 ;
66837   Dali::Actor *argp2 ;
66838   Dali::Actor result;
66839
66840   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66841   argp2 = (Dali::Actor *)jarg2;
66842   if (!argp2) {
66843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66844     return 0;
66845   }
66846   arg2 = *argp2;
66847   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66848   arg4 = jarg4 ? true : false;
66849   {
66850     try {
66851       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66852     } catch (std::out_of_range& e) {
66853       {
66854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66855       };
66856     } catch (std::exception& e) {
66857       {
66858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66859       };
66860     } catch (Dali::DaliException e) {
66861       {
66862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66863       };
66864     } catch (...) {
66865       {
66866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66867       };
66868     }
66869   }
66870
66871   jresult = new Dali::Actor((const Dali::Actor &)result);
66872   return jresult;
66873 }
66874
66875
66876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66877   void * jresult ;
66878   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66879   Dali::Actor arg2 ;
66880   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66881   bool arg4 ;
66882   Dali::Actor *argp2 ;
66883   Dali::Actor result;
66884
66885   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66886   argp2 = (Dali::Actor *)jarg2;
66887   if (!argp2) {
66888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66889     return 0;
66890   }
66891   arg2 = *argp2;
66892   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66893   arg4 = jarg4 ? true : false;
66894   {
66895     try {
66896       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66897     } catch (std::out_of_range& e) {
66898       {
66899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66900       };
66901     } catch (std::exception& e) {
66902       {
66903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66904       };
66905     } catch (Dali::DaliException e) {
66906       {
66907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66908       };
66909     } catch (...) {
66910       {
66911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66912       };
66913     }
66914   }
66915
66916   jresult = new Dali::Actor((const Dali::Actor &)result);
66917   return jresult;
66918 }
66919
66920
66921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66922   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66923   Dali::Actor arg2 ;
66924   Dali::Actor *argp2 ;
66925
66926   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66927   argp2 = (Dali::Actor *)jarg2;
66928   if (!argp2) {
66929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66930     return ;
66931   }
66932   arg2 = *argp2;
66933   {
66934     try {
66935       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66936     } catch (std::out_of_range& e) {
66937       {
66938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66939       };
66940     } catch (std::exception& e) {
66941       {
66942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66943       };
66944     } catch (Dali::DaliException e) {
66945       {
66946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66947       };
66948     } catch (...) {
66949       {
66950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66951       };
66952     }
66953   }
66954
66955 }
66956
66957
66958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(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)->Dali::Toolkit::Internal::Control::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 unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66996   unsigned int jresult ;
66997   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66998   bool result;
66999
67000   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67001   {
67002     try {
67003       result = (bool)(arg1)->OnKeyboardEnter();
67004     } catch (std::out_of_range& e) {
67005       {
67006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67007       };
67008     } catch (std::exception& e) {
67009       {
67010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67011       };
67012     } catch (Dali::DaliException e) {
67013       {
67014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67015       };
67016     } catch (...) {
67017       {
67018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67019       };
67020     }
67021   }
67022
67023   jresult = result;
67024   return jresult;
67025 }
67026
67027
67028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
67029   unsigned int jresult ;
67030   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67031   bool result;
67032
67033   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67034   {
67035     try {
67036       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
67037     } catch (std::out_of_range& e) {
67038       {
67039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67040       };
67041     } catch (std::exception& e) {
67042       {
67043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67044       };
67045     } catch (Dali::DaliException e) {
67046       {
67047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67048       };
67049     } catch (...) {
67050       {
67051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67052       };
67053     }
67054   }
67055
67056   jresult = result;
67057   return jresult;
67058 }
67059
67060
67061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
67062   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67063   Dali::PinchGesture *arg2 = 0 ;
67064
67065   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67066   arg2 = (Dali::PinchGesture *)jarg2;
67067   if (!arg2) {
67068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
67069     return ;
67070   }
67071   {
67072     try {
67073       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
67074     } catch (std::out_of_range& e) {
67075       {
67076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67077       };
67078     } catch (std::exception& e) {
67079       {
67080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67081       };
67082     } catch (Dali::DaliException e) {
67083       {
67084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67085       };
67086     } catch (...) {
67087       {
67088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67089       };
67090     }
67091   }
67092
67093 }
67094
67095
67096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67097   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67098   Dali::PinchGesture *arg2 = 0 ;
67099
67100   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67101   arg2 = (Dali::PinchGesture *)jarg2;
67102   if (!arg2) {
67103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
67104     return ;
67105   }
67106   {
67107     try {
67108       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
67109     } catch (std::out_of_range& e) {
67110       {
67111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67112       };
67113     } catch (std::exception& e) {
67114       {
67115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67116       };
67117     } catch (Dali::DaliException e) {
67118       {
67119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67120       };
67121     } catch (...) {
67122       {
67123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67124       };
67125     }
67126   }
67127
67128 }
67129
67130
67131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
67132   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67133   Dali::PanGesture *arg2 = 0 ;
67134
67135   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67136   arg2 = (Dali::PanGesture *)jarg2;
67137   if (!arg2) {
67138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67139     return ;
67140   }
67141   {
67142     try {
67143       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
67144     } catch (std::out_of_range& e) {
67145       {
67146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67147       };
67148     } catch (std::exception& e) {
67149       {
67150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67151       };
67152     } catch (Dali::DaliException e) {
67153       {
67154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67155       };
67156     } catch (...) {
67157       {
67158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67159       };
67160     }
67161   }
67162
67163 }
67164
67165
67166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67167   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67168   Dali::PanGesture *arg2 = 0 ;
67169
67170   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67171   arg2 = (Dali::PanGesture *)jarg2;
67172   if (!arg2) {
67173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67174     return ;
67175   }
67176   {
67177     try {
67178       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
67179     } catch (std::out_of_range& e) {
67180       {
67181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67182       };
67183     } catch (std::exception& e) {
67184       {
67185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67186       };
67187     } catch (Dali::DaliException e) {
67188       {
67189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67190       };
67191     } catch (...) {
67192       {
67193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67194       };
67195     }
67196   }
67197
67198 }
67199
67200
67201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
67202   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67203   Dali::TapGesture *arg2 = 0 ;
67204
67205   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67206   arg2 = (Dali::TapGesture *)jarg2;
67207   if (!arg2) {
67208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67209     return ;
67210   }
67211   {
67212     try {
67213       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
67214     } catch (std::out_of_range& e) {
67215       {
67216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67217       };
67218     } catch (std::exception& e) {
67219       {
67220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67221       };
67222     } catch (Dali::DaliException e) {
67223       {
67224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67225       };
67226     } catch (...) {
67227       {
67228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67229       };
67230     }
67231   }
67232
67233 }
67234
67235
67236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67237   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67238   Dali::TapGesture *arg2 = 0 ;
67239
67240   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67241   arg2 = (Dali::TapGesture *)jarg2;
67242   if (!arg2) {
67243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67244     return ;
67245   }
67246   {
67247     try {
67248       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
67249     } catch (std::out_of_range& e) {
67250       {
67251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67252       };
67253     } catch (std::exception& e) {
67254       {
67255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67256       };
67257     } catch (Dali::DaliException e) {
67258       {
67259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67260       };
67261     } catch (...) {
67262       {
67263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67264       };
67265     }
67266   }
67267
67268 }
67269
67270
67271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
67272   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67273   Dali::LongPressGesture *arg2 = 0 ;
67274
67275   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67276   arg2 = (Dali::LongPressGesture *)jarg2;
67277   if (!arg2) {
67278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67279     return ;
67280   }
67281   {
67282     try {
67283       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
67284     } catch (std::out_of_range& e) {
67285       {
67286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67287       };
67288     } catch (std::exception& e) {
67289       {
67290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67291       };
67292     } catch (Dali::DaliException e) {
67293       {
67294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67295       };
67296     } catch (...) {
67297       {
67298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67299       };
67300     }
67301   }
67302
67303 }
67304
67305
67306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67307   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67308   Dali::LongPressGesture *arg2 = 0 ;
67309
67310   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67311   arg2 = (Dali::LongPressGesture *)jarg2;
67312   if (!arg2) {
67313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67314     return ;
67315   }
67316   {
67317     try {
67318       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
67319     } catch (std::out_of_range& e) {
67320       {
67321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67322       };
67323     } catch (std::exception& e) {
67324       {
67325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67326       };
67327     } catch (Dali::DaliException e) {
67328       {
67329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67330       };
67331     } catch (...) {
67332       {
67333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67334       };
67335     }
67336   }
67337
67338 }
67339
67340
67341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
67342   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67343   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67344   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67345
67346   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67347   arg2 = (Dali::SlotObserver *)jarg2;
67348   arg3 = (Dali::CallbackBase *)jarg3;
67349   {
67350     try {
67351       (arg1)->SignalConnected(arg2,arg3);
67352     } catch (std::out_of_range& e) {
67353       {
67354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67355       };
67356     } catch (std::exception& e) {
67357       {
67358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67359       };
67360     } catch (Dali::DaliException e) {
67361       {
67362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67363       };
67364     } catch (...) {
67365       {
67366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67367       };
67368     }
67369   }
67370
67371 }
67372
67373
67374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67375   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67376   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67377   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67378
67379   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67380   arg2 = (Dali::SlotObserver *)jarg2;
67381   arg3 = (Dali::CallbackBase *)jarg3;
67382   {
67383     try {
67384       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
67385     } catch (std::out_of_range& e) {
67386       {
67387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67388       };
67389     } catch (std::exception& e) {
67390       {
67391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67392       };
67393     } catch (Dali::DaliException e) {
67394       {
67395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67396       };
67397     } catch (...) {
67398       {
67399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67400       };
67401     }
67402   }
67403
67404 }
67405
67406
67407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
67408   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67409   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67410   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67411
67412   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67413   arg2 = (Dali::SlotObserver *)jarg2;
67414   arg3 = (Dali::CallbackBase *)jarg3;
67415   {
67416     try {
67417       (arg1)->SignalDisconnected(arg2,arg3);
67418     } catch (std::out_of_range& e) {
67419       {
67420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67421       };
67422     } catch (std::exception& e) {
67423       {
67424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67425       };
67426     } catch (Dali::DaliException e) {
67427       {
67428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67429       };
67430     } catch (...) {
67431       {
67432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67433       };
67434     }
67435   }
67436
67437 }
67438
67439
67440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67441   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67442   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67443   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67444
67445   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67446   arg2 = (Dali::SlotObserver *)jarg2;
67447   arg3 = (Dali::CallbackBase *)jarg3;
67448   {
67449     try {
67450       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
67451     } catch (std::out_of_range& e) {
67452       {
67453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67454       };
67455     } catch (std::exception& e) {
67456       {
67457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67458       };
67459     } catch (Dali::DaliException e) {
67460       {
67461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67462       };
67463     } catch (...) {
67464       {
67465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67466       };
67467     }
67468   }
67469
67470 }
67471
67472
67473 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) {
67474   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
67475   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
67476   if (director) {
67477     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);
67478   }
67479 }
67480
67481
67482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
67483   void * jresult ;
67484   Dali::Toolkit::Control *arg1 = 0 ;
67485   Dali::Toolkit::Internal::Control *result = 0 ;
67486
67487   arg1 = (Dali::Toolkit::Control *)jarg1;
67488   if (!arg1) {
67489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67490     return 0;
67491   }
67492   {
67493     try {
67494       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
67495     } catch (std::out_of_range& e) {
67496       {
67497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67498       };
67499     } catch (std::exception& e) {
67500       {
67501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67502       };
67503     } catch (Dali::DaliException e) {
67504       {
67505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67506       };
67507     } catch (...) {
67508       {
67509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67510       };
67511     }
67512   }
67513
67514   jresult = (void *)result;
67515   return jresult;
67516 }
67517
67518
67519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67520   int jresult ;
67521   int result;
67522
67523   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67524   jresult = (int)result;
67525   return jresult;
67526 }
67527
67528
67529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67530   int jresult ;
67531   int result;
67532
67533   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67534   jresult = (int)result;
67535   return jresult;
67536 }
67537
67538
67539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67540   int jresult ;
67541   int result;
67542
67543   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67544   jresult = (int)result;
67545   return jresult;
67546 }
67547
67548
67549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67550   int jresult ;
67551   int result;
67552
67553   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67554   jresult = (int)result;
67555   return jresult;
67556 }
67557
67558
67559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67560   int jresult ;
67561   int result;
67562
67563   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67564   jresult = (int)result;
67565   return jresult;
67566 }
67567
67568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67569   int jresult ;
67570   int result;
67571
67572   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67573   jresult = (int)result;
67574   return jresult;
67575 }
67576
67577
67578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67579   int jresult ;
67580   int result;
67581
67582   result = (int)Dali::Toolkit::Control::Property::PADDING;
67583   jresult = (int)result;
67584   return jresult;
67585 }
67586
67587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67588   void * jresult ;
67589   Dali::Toolkit::Control::Property *result = 0 ;
67590
67591   {
67592     try {
67593       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67594     } catch (std::out_of_range& e) {
67595       {
67596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67597       };
67598     } catch (std::exception& e) {
67599       {
67600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67601       };
67602     } catch (Dali::DaliException e) {
67603       {
67604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67605       };
67606     } catch (...) {
67607       {
67608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67609       };
67610     }
67611   }
67612
67613   jresult = (void *)result;
67614   return jresult;
67615 }
67616
67617
67618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67619   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67620
67621   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67622   {
67623     try {
67624       delete arg1;
67625     } catch (std::out_of_range& e) {
67626       {
67627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67628       };
67629     } catch (std::exception& e) {
67630       {
67631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67632       };
67633     } catch (Dali::DaliException e) {
67634       {
67635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67636       };
67637     } catch (...) {
67638       {
67639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67640       };
67641     }
67642   }
67643
67644 }
67645
67646
67647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67648   void * jresult ;
67649   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67650
67651   {
67652     try {
67653       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67654     } catch (std::out_of_range& e) {
67655       {
67656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67657       };
67658     } catch (std::exception& e) {
67659       {
67660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67661       };
67662     } catch (Dali::DaliException e) {
67663       {
67664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67665       };
67666     } catch (...) {
67667       {
67668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67669       };
67670     }
67671   }
67672
67673   jresult = (void *)result;
67674   return jresult;
67675 }
67676
67677
67678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67679   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67680
67681   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67682   {
67683     try {
67684       delete arg1;
67685     } catch (std::out_of_range& e) {
67686       {
67687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67688       };
67689     } catch (std::exception& e) {
67690       {
67691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67692       };
67693     } catch (Dali::DaliException e) {
67694       {
67695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67696       };
67697     } catch (...) {
67698       {
67699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67700       };
67701     }
67702   }
67703
67704 }
67705
67706
67707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67708   void * jresult ;
67709   Dali::Toolkit::Control result;
67710
67711   {
67712     try {
67713       result = Dali::Toolkit::Control::New();
67714     } catch (std::out_of_range& e) {
67715       {
67716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67717       };
67718     } catch (std::exception& e) {
67719       {
67720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67721       };
67722     } catch (Dali::DaliException e) {
67723       {
67724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67725       };
67726     } catch (...) {
67727       {
67728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67729       };
67730     }
67731   }
67732
67733   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67734   return jresult;
67735 }
67736
67737
67738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67739   void * jresult ;
67740   Dali::Toolkit::Control *result = 0 ;
67741
67742   {
67743     try {
67744       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67745     } catch (std::out_of_range& e) {
67746       {
67747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67748       };
67749     } catch (std::exception& e) {
67750       {
67751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67752       };
67753     } catch (Dali::DaliException e) {
67754       {
67755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67756       };
67757     } catch (...) {
67758       {
67759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67760       };
67761     }
67762   }
67763
67764   jresult = (void *)result;
67765   return jresult;
67766 }
67767
67768
67769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67770   void * jresult ;
67771   Dali::Toolkit::Control *arg1 = 0 ;
67772   Dali::Toolkit::Control *result = 0 ;
67773
67774   arg1 = (Dali::Toolkit::Control *)jarg1;
67775   if (!arg1) {
67776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67777     return 0;
67778   }
67779   {
67780     try {
67781       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
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_delete_View(void * jarg1) {
67807   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67808
67809   arg1 = (Dali::Toolkit::Control *)jarg1;
67810   {
67811     try {
67812       delete arg1;
67813     } catch (std::out_of_range& e) {
67814       {
67815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67816       };
67817     } catch (std::exception& e) {
67818       {
67819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67820       };
67821     } catch (Dali::DaliException e) {
67822       {
67823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67824       };
67825     } catch (...) {
67826       {
67827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67828       };
67829     }
67830   }
67831
67832 }
67833
67834
67835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67836   void * jresult ;
67837   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67838   Dali::Toolkit::Control *arg2 = 0 ;
67839   Dali::Toolkit::Control *result = 0 ;
67840
67841   arg1 = (Dali::Toolkit::Control *)jarg1;
67842   arg2 = (Dali::Toolkit::Control *)jarg2;
67843   if (!arg2) {
67844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67845     return 0;
67846   }
67847   {
67848     try {
67849       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67850     } catch (std::out_of_range& e) {
67851       {
67852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67853       };
67854     } catch (std::exception& e) {
67855       {
67856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67857       };
67858     } catch (Dali::DaliException e) {
67859       {
67860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67861       };
67862     } catch (...) {
67863       {
67864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67865       };
67866     }
67867   }
67868
67869   jresult = (void *)result;
67870   return jresult;
67871 }
67872
67873
67874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67875   void * jresult ;
67876   Dali::BaseHandle arg1 ;
67877   Dali::BaseHandle *argp1 ;
67878   Dali::Toolkit::Control result;
67879
67880   argp1 = (Dali::BaseHandle *)jarg1;
67881   if (!argp1) {
67882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67883     return 0;
67884   }
67885   arg1 = *argp1;
67886   {
67887     try {
67888       result = Dali::Toolkit::Control::DownCast(arg1);
67889     } catch (std::out_of_range& e) {
67890       {
67891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67892       };
67893     } catch (std::exception& e) {
67894       {
67895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67896       };
67897     } catch (Dali::DaliException e) {
67898       {
67899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67900       };
67901     } catch (...) {
67902       {
67903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67904       };
67905     }
67906   }
67907
67908   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67909   return jresult;
67910 }
67911
67912
67913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67914   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67915
67916   arg1 = (Dali::Toolkit::Control *)jarg1;
67917   {
67918     try {
67919       (arg1)->SetKeyInputFocus();
67920     } catch (std::out_of_range& e) {
67921       {
67922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67923       };
67924     } catch (std::exception& e) {
67925       {
67926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67927       };
67928     } catch (Dali::DaliException e) {
67929       {
67930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67931       };
67932     } catch (...) {
67933       {
67934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67935       };
67936     }
67937   }
67938
67939 }
67940
67941
67942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67943   unsigned int jresult ;
67944   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67945   bool result;
67946
67947   arg1 = (Dali::Toolkit::Control *)jarg1;
67948   {
67949     try {
67950       result = (bool)(arg1)->HasKeyInputFocus();
67951     } catch (std::out_of_range& e) {
67952       {
67953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67954       };
67955     } catch (std::exception& e) {
67956       {
67957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67958       };
67959     } catch (Dali::DaliException e) {
67960       {
67961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67962       };
67963     } catch (...) {
67964       {
67965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67966       };
67967     }
67968   }
67969
67970   jresult = result;
67971   return jresult;
67972 }
67973
67974
67975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67976   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67977
67978   arg1 = (Dali::Toolkit::Control *)jarg1;
67979   {
67980     try {
67981       (arg1)->ClearKeyInputFocus();
67982     } catch (std::out_of_range& e) {
67983       {
67984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67985       };
67986     } catch (std::exception& e) {
67987       {
67988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67989       };
67990     } catch (Dali::DaliException e) {
67991       {
67992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67993       };
67994     } catch (...) {
67995       {
67996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67997       };
67998     }
67999   }
68000
68001 }
68002
68003
68004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
68005   void * jresult ;
68006   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68007   Dali::PinchGestureDetector result;
68008
68009   arg1 = (Dali::Toolkit::Control *)jarg1;
68010   {
68011     try {
68012       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
68013     } catch (std::out_of_range& e) {
68014       {
68015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68016       };
68017     } catch (std::exception& e) {
68018       {
68019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68020       };
68021     } catch (Dali::DaliException e) {
68022       {
68023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68024       };
68025     } catch (...) {
68026       {
68027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68028       };
68029     }
68030   }
68031
68032   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
68033   return jresult;
68034 }
68035
68036
68037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
68038   void * jresult ;
68039   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68040   Dali::PanGestureDetector result;
68041
68042   arg1 = (Dali::Toolkit::Control *)jarg1;
68043   {
68044     try {
68045       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
68046     } catch (std::out_of_range& e) {
68047       {
68048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68049       };
68050     } catch (std::exception& e) {
68051       {
68052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68053       };
68054     } catch (Dali::DaliException e) {
68055       {
68056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68057       };
68058     } catch (...) {
68059       {
68060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68061       };
68062     }
68063   }
68064
68065   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
68066   return jresult;
68067 }
68068
68069
68070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
68071   void * jresult ;
68072   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68073   Dali::TapGestureDetector result;
68074
68075   arg1 = (Dali::Toolkit::Control *)jarg1;
68076   {
68077     try {
68078       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
68079     } catch (std::out_of_range& e) {
68080       {
68081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68082       };
68083     } catch (std::exception& e) {
68084       {
68085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68086       };
68087     } catch (Dali::DaliException e) {
68088       {
68089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68090       };
68091     } catch (...) {
68092       {
68093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68094       };
68095     }
68096   }
68097
68098   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
68099   return jresult;
68100 }
68101
68102
68103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
68104   void * jresult ;
68105   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68106   Dali::LongPressGestureDetector result;
68107
68108   arg1 = (Dali::Toolkit::Control *)jarg1;
68109   {
68110     try {
68111       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
68112     } catch (std::out_of_range& e) {
68113       {
68114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68115       };
68116     } catch (std::exception& e) {
68117       {
68118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68119       };
68120     } catch (Dali::DaliException e) {
68121       {
68122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68123       };
68124     } catch (...) {
68125       {
68126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68127       };
68128     }
68129   }
68130
68131   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
68132   return jresult;
68133 }
68134
68135
68136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
68137   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68138   std::string *arg2 = 0 ;
68139
68140   arg1 = (Dali::Toolkit::Control *)jarg1;
68141   if (!jarg2) {
68142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68143     return ;
68144   }
68145   std::string arg2_str(jarg2);
68146   arg2 = &arg2_str;
68147   {
68148     try {
68149       (arg1)->SetStyleName((std::string const &)*arg2);
68150     } catch (std::out_of_range& e) {
68151       {
68152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68153       };
68154     } catch (std::exception& e) {
68155       {
68156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68157       };
68158     } catch (Dali::DaliException e) {
68159       {
68160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68161       };
68162     } catch (...) {
68163       {
68164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68165       };
68166     }
68167   }
68168
68169
68170   //argout typemap for const std::string&
68171
68172 }
68173
68174
68175 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
68176   char * jresult ;
68177   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68178   std::string *result = 0 ;
68179
68180   arg1 = (Dali::Toolkit::Control *)jarg1;
68181   {
68182     try {
68183       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
68184     } catch (std::out_of_range& e) {
68185       {
68186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68187       };
68188     } catch (std::exception& e) {
68189       {
68190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68191       };
68192     } catch (Dali::DaliException e) {
68193       {
68194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68195       };
68196     } catch (...) {
68197       {
68198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68199       };
68200     }
68201   }
68202
68203   jresult = SWIG_csharp_string_callback(result->c_str());
68204   return jresult;
68205 }
68206
68207
68208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
68209   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68210   Dali::Vector4 *arg2 = 0 ;
68211
68212   arg1 = (Dali::Toolkit::Control *)jarg1;
68213   arg2 = (Dali::Vector4 *)jarg2;
68214   if (!arg2) {
68215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68216     return ;
68217   }
68218   {
68219     try {
68220       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
68221     } catch (std::out_of_range& e) {
68222       {
68223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68224       };
68225     } catch (std::exception& e) {
68226       {
68227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68228       };
68229     } catch (Dali::DaliException e) {
68230       {
68231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68232       };
68233     } catch (...) {
68234       {
68235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68236       };
68237     }
68238   }
68239
68240 }
68241
68242
68243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
68244   void * jresult ;
68245   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68246   Dali::Vector4 result;
68247
68248   arg1 = (Dali::Toolkit::Control *)jarg1;
68249   {
68250     try {
68251       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
68252     } catch (std::out_of_range& e) {
68253       {
68254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68255       };
68256     } catch (std::exception& e) {
68257       {
68258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68259       };
68260     } catch (Dali::DaliException e) {
68261       {
68262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68263       };
68264     } catch (...) {
68265       {
68266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68267       };
68268     }
68269   }
68270
68271   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68272   return jresult;
68273 }
68274
68275
68276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
68277   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68278   Dali::Image arg2 ;
68279   Dali::Image *argp2 ;
68280
68281   arg1 = (Dali::Toolkit::Control *)jarg1;
68282   argp2 = (Dali::Image *)jarg2;
68283   if (!argp2) {
68284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
68285     return ;
68286   }
68287   arg2 = *argp2;
68288   {
68289     try {
68290       (arg1)->SetBackgroundImage(arg2);
68291     } catch (std::out_of_range& e) {
68292       {
68293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68294       };
68295     } catch (std::exception& e) {
68296       {
68297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68298       };
68299     } catch (Dali::DaliException e) {
68300       {
68301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68302       };
68303     } catch (...) {
68304       {
68305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68306       };
68307     }
68308   }
68309
68310 }
68311
68312
68313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
68314   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68315
68316   arg1 = (Dali::Toolkit::Control *)jarg1;
68317   {
68318     try {
68319       (arg1)->ClearBackground();
68320     } catch (std::out_of_range& e) {
68321       {
68322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68323       };
68324     } catch (std::exception& e) {
68325       {
68326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68327       };
68328     } catch (Dali::DaliException e) {
68329       {
68330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68331       };
68332     } catch (...) {
68333       {
68334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68335       };
68336     }
68337   }
68338
68339 }
68340
68341
68342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
68343   void * jresult ;
68344   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68345   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
68346
68347   arg1 = (Dali::Toolkit::Control *)jarg1;
68348   {
68349     try {
68350       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
68351     } catch (std::out_of_range& e) {
68352       {
68353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68354       };
68355     } catch (std::exception& e) {
68356       {
68357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68358       };
68359     } catch (Dali::DaliException e) {
68360       {
68361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68362       };
68363     } catch (...) {
68364       {
68365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68366       };
68367     }
68368   }
68369
68370   jresult = (void *)result;
68371   return jresult;
68372 }
68373
68374
68375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
68376   void * jresult ;
68377   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68378   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68379
68380   arg1 = (Dali::Toolkit::Control *)jarg1;
68381   {
68382     try {
68383       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
68384     } catch (std::out_of_range& e) {
68385       {
68386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68387       };
68388     } catch (std::exception& e) {
68389       {
68390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68391       };
68392     } catch (Dali::DaliException e) {
68393       {
68394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68395       };
68396     } catch (...) {
68397       {
68398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68399       };
68400     }
68401   }
68402
68403   jresult = (void *)result;
68404   return jresult;
68405 }
68406
68407
68408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
68409   void * jresult ;
68410   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68411   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68412
68413   arg1 = (Dali::Toolkit::Control *)jarg1;
68414   {
68415     try {
68416       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
68417     } catch (std::out_of_range& e) {
68418       {
68419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68420       };
68421     } catch (std::exception& e) {
68422       {
68423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68424       };
68425     } catch (Dali::DaliException e) {
68426       {
68427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68428       };
68429     } catch (...) {
68430       {
68431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68432       };
68433     }
68434   }
68435
68436   jresult = (void *)result;
68437   return jresult;
68438 }
68439
68440
68441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
68442   void * jresult ;
68443   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68444   Dali::Toolkit::Control *result = 0 ;
68445
68446   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68447   if (!arg1) {
68448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68449     return 0;
68450   }
68451   {
68452     try {
68453       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
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 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
68478 {
68479   int jresult;
68480   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68481   arg1 = (Dali::Toolkit::Control *)jarg1;
68482
68483   if (!arg1) {
68484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68485     return 0;
68486   }
68487
68488   Dali::Property::Index arg2 = 0 ;
68489   arg2 = (Dali::Property::Index)jarg2;
68490
68491   Toolkit::Visual::ResourceStatus result;
68492   {
68493     try {
68494       result = arg1->GetVisualResourceStatus(arg2);
68495     } catch (std::out_of_range& e) {
68496       {
68497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68498       };
68499     } catch (std::exception& e) {
68500       {
68501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68502       };
68503     } catch (...) {
68504       {
68505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68506       };
68507     }
68508   }
68509   jresult = (int)(result);
68510   return jresult;
68511 }
68512
68513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68514 {
68515   void * jresult;
68516   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68517   arg1 = (Dali::Toolkit::Control *)jarg1;
68518
68519   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68520
68521   Dali::Toolkit::TransitionData *arg2 = 0 ;
68522   Dali::Animation result;
68523
68524   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68525   if (!arg2) {
68526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68527     return 0;
68528   }
68529   {
68530     try {
68531       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*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 (Dali::DaliException e) {
68541       {
68542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68543       };
68544     } catch (...) {
68545       {
68546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68547       };
68548     }
68549   }
68550
68551   jresult = new Dali::Animation((const Dali::Animation &)result);
68552   return jresult;
68553 }
68554
68555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68556 {
68557   Dali::Toolkit::Control arg1;
68558   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68559
68560   if (!argp1) {
68561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68562   }
68563   arg1 = *argp1;
68564
68565   Dali::Property::Index arg2 = 0 ;
68566   arg2 = (Dali::Property::Index)jarg2;
68567
68568   Dali::Property::Index arg3 = 0 ;
68569   arg3 = (Dali::Property::Index)jarg3;
68570
68571   Dali::Property::Value arg4;
68572   arg4 = (Dali::Property::Value *)jarg4;
68573
68574   {
68575     try {
68576       DevelControl::DoAction(arg1, arg2, arg3, arg4);
68577     } catch (std::out_of_range& e) {
68578       {
68579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68580       };
68581     } catch (std::exception& e) {
68582       {
68583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68584       };
68585     } catch (...) {
68586       {
68587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68588       };
68589     }
68590   }
68591
68592
68593 }
68594
68595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_0(void * jarg1) {
68596   void * jresult ;
68597   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68598   Dali::Toolkit::LayoutItem result;
68599
68600   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68601   if (!arg1) {
68602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68603     return 0;
68604   }
68605   {
68606     try {
68607       result = Dali::Toolkit::DevelControl::GetLayout(*arg1);
68608     } catch (std::out_of_range& e) {
68609       {
68610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68611       };
68612     } catch (std::exception& e) {
68613       {
68614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68615       };
68616     } catch (...) {
68617       {
68618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68619       };
68620     }
68621   }
68622   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68623   return jresult;
68624 }
68625
68626
68627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_1(void * jarg1) {
68628   void * jresult ;
68629   Dali::Toolkit::Control arg1 ;
68630   Dali::Toolkit::Control *argp1 ;
68631   Dali::Toolkit::LayoutItem result;
68632
68633   argp1 = (Dali::Toolkit::Control *)jarg1;
68634   if (!argp1) {
68635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68636     return 0;
68637   }
68638   arg1 = *argp1;
68639   {
68640     try {
68641       result = Dali::Toolkit::DevelControl::GetLayout(arg1);
68642     } catch (std::out_of_range& e) {
68643       {
68644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68645       };
68646     } catch (std::exception& e) {
68647       {
68648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68649       };
68650     } catch (...) {
68651       {
68652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68653       };
68654     }
68655   }
68656   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68657   return jresult;
68658 }
68659
68660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_0(void * jarg1, void * jarg2) {
68661   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68662   Dali::Toolkit::LayoutItem arg2 ;
68663   Dali::Toolkit::LayoutItem *argp2 ;
68664
68665   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68666   if (!arg1) {
68667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68668     return ;
68669   }
68670   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68671   if (!argp2) {
68672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68673     return ;
68674   }
68675   arg2 = *argp2;
68676   {
68677     try {
68678       Dali::Toolkit::DevelControl::SetLayout(*arg1,arg2);
68679     } catch (std::out_of_range& e) {
68680       {
68681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68682       };
68683     } catch (std::exception& e) {
68684       {
68685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68686       };
68687     } catch (...) {
68688       {
68689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68690       };
68691     }
68692   }
68693 }
68694
68695
68696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_1(void * jarg1, void * jarg2) {
68697   Dali::Toolkit::Control arg1 ;
68698   Dali::Toolkit::LayoutItem arg2 ;
68699   Dali::Toolkit::Control *argp1 ;
68700   Dali::Toolkit::LayoutItem *argp2 ;
68701
68702   argp1 = (Dali::Toolkit::Control *)jarg1;
68703   if (!argp1) {
68704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68705     return ;
68706   }
68707   arg1 = *argp1;
68708   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68709   if (!argp2) {
68710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68711     return ;
68712   }
68713   arg2 = *argp2;
68714   {
68715     try {
68716       Dali::Toolkit::DevelControl::SetLayout(arg1,arg2);
68717     } catch (std::out_of_range& e) {
68718       {
68719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68720       };
68721     } catch (std::exception& e) {
68722       {
68723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68724       };
68725     } catch (...) {
68726       {
68727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68728       };
68729     }
68730   }
68731 }
68732
68733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68734   void * jresult ;
68735   Dali::Toolkit::Control *arg1 = 0 ;
68736   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68737
68738   arg1 = (Dali::Toolkit::Control *)jarg1;
68739   if (!arg1) {
68740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68741     return 0;
68742   }
68743   {
68744     try {
68745       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68746     } catch (std::out_of_range& e) {
68747       {
68748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68749       };
68750     } catch (std::exception& e) {
68751       {
68752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68753       };
68754     } catch (Dali::DaliException e) {
68755       {
68756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68757       };
68758     } catch (...) {
68759       {
68760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68761       };
68762     }
68763   }
68764
68765   jresult = (void *)result;
68766   return jresult;
68767 }
68768
68769
68770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68771   unsigned int jresult ;
68772   Dali::Toolkit::Control *arg1 = 0 ;
68773   bool result;
68774
68775   arg1 = (Dali::Toolkit::Control *)jarg1;
68776   if (!arg1) {
68777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68778     return 0;
68779   }
68780   {
68781     try {
68782       result = (bool)arg1->IsResourceReady();
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 = result;
68803   return jresult;
68804 }
68805
68806
68807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68808   void * jresult ;
68809   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68810
68811   {
68812     try {
68813       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68814     } catch (std::out_of_range& e) {
68815       {
68816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68817       };
68818     } catch (std::exception& e) {
68819       {
68820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68821       };
68822     } catch (Dali::DaliException e) {
68823       {
68824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68825       };
68826     } catch (...) {
68827       {
68828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68829       };
68830     }
68831   }
68832
68833   jresult = (void *)result;
68834   return jresult;
68835 }
68836
68837
68838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68839   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68840
68841   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68842   {
68843     try {
68844       delete arg1;
68845     } catch (std::out_of_range& e) {
68846       {
68847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68848       };
68849     } catch (std::exception& e) {
68850       {
68851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68852       };
68853     } catch (Dali::DaliException e) {
68854       {
68855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68856       };
68857     } catch (...) {
68858       {
68859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68860       };
68861     }
68862   }
68863
68864 }
68865
68866
68867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68868   void * jresult ;
68869   Dali::Toolkit::KeyInputFocusManager result;
68870
68871   {
68872     try {
68873       result = Dali::Toolkit::KeyInputFocusManager::Get();
68874     } catch (std::out_of_range& e) {
68875       {
68876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68877       };
68878     } catch (std::exception& e) {
68879       {
68880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68881       };
68882     } catch (Dali::DaliException e) {
68883       {
68884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68885       };
68886     } catch (...) {
68887       {
68888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68889       };
68890     }
68891   }
68892
68893   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68894   return jresult;
68895 }
68896
68897
68898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68899   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68900   Dali::Toolkit::Control arg2 ;
68901   Dali::Toolkit::Control *argp2 ;
68902
68903   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68904   argp2 = (Dali::Toolkit::Control *)jarg2;
68905   if (!argp2) {
68906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68907     return ;
68908   }
68909   arg2 = *argp2;
68910   {
68911     try {
68912       (arg1)->SetFocus(arg2);
68913     } catch (std::out_of_range& e) {
68914       {
68915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68916       };
68917     } catch (std::exception& e) {
68918       {
68919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68920       };
68921     } catch (Dali::DaliException e) {
68922       {
68923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68924       };
68925     } catch (...) {
68926       {
68927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68928       };
68929     }
68930   }
68931
68932 }
68933
68934
68935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68936   void * jresult ;
68937   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68938   Dali::Toolkit::Control result;
68939
68940   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68941   {
68942     try {
68943       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68944     } catch (std::out_of_range& e) {
68945       {
68946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68947       };
68948     } catch (std::exception& e) {
68949       {
68950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68951       };
68952     } catch (Dali::DaliException e) {
68953       {
68954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68955       };
68956     } catch (...) {
68957       {
68958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68959       };
68960     }
68961   }
68962
68963   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68964   return jresult;
68965 }
68966
68967
68968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68969   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68970   Dali::Toolkit::Control arg2 ;
68971   Dali::Toolkit::Control *argp2 ;
68972
68973   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68974   argp2 = (Dali::Toolkit::Control *)jarg2;
68975   if (!argp2) {
68976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68977     return ;
68978   }
68979   arg2 = *argp2;
68980   {
68981     try {
68982       (arg1)->RemoveFocus(arg2);
68983     } catch (std::out_of_range& e) {
68984       {
68985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68986       };
68987     } catch (std::exception& e) {
68988       {
68989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68990       };
68991     } catch (Dali::DaliException e) {
68992       {
68993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68994       };
68995     } catch (...) {
68996       {
68997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68998       };
68999     }
69000   }
69001
69002 }
69003
69004
69005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
69006   void * jresult ;
69007   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
69008   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
69009
69010   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
69011   {
69012     try {
69013       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
69014     } catch (std::out_of_range& e) {
69015       {
69016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69017       };
69018     } catch (std::exception& e) {
69019       {
69020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69021       };
69022     } catch (Dali::DaliException e) {
69023       {
69024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69025       };
69026     } catch (...) {
69027       {
69028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69029       };
69030     }
69031   }
69032
69033   jresult = (void *)result;
69034   return jresult;
69035 }
69036
69037
69038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
69039   void * jresult ;
69040   Dali::Toolkit::Alignment::Padding *result = 0 ;
69041
69042   {
69043     try {
69044       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
69045     } catch (std::out_of_range& e) {
69046       {
69047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69048       };
69049     } catch (std::exception& e) {
69050       {
69051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69052       };
69053     } catch (Dali::DaliException e) {
69054       {
69055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69056       };
69057     } catch (...) {
69058       {
69059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69060       };
69061     }
69062   }
69063
69064   jresult = (void *)result;
69065   return jresult;
69066 }
69067
69068
69069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
69070   void * jresult ;
69071   float arg1 ;
69072   float arg2 ;
69073   float arg3 ;
69074   float arg4 ;
69075   Dali::Toolkit::Alignment::Padding *result = 0 ;
69076
69077   arg1 = (float)jarg1;
69078   arg2 = (float)jarg2;
69079   arg3 = (float)jarg3;
69080   arg4 = (float)jarg4;
69081   {
69082     try {
69083       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
69084     } catch (std::out_of_range& e) {
69085       {
69086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69087       };
69088     } catch (std::exception& e) {
69089       {
69090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69091       };
69092     } catch (Dali::DaliException e) {
69093       {
69094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69095       };
69096     } catch (...) {
69097       {
69098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69099       };
69100     }
69101   }
69102
69103   jresult = (void *)result;
69104   return jresult;
69105 }
69106
69107
69108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
69109   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69110   float arg2 ;
69111
69112   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69113   arg2 = (float)jarg2;
69114   if (arg1) (arg1)->left = arg2;
69115 }
69116
69117
69118 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
69119   float jresult ;
69120   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69121   float result;
69122
69123   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69124   result = (float) ((arg1)->left);
69125   jresult = result;
69126   return jresult;
69127 }
69128
69129
69130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
69131   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69132   float arg2 ;
69133
69134   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69135   arg2 = (float)jarg2;
69136   if (arg1) (arg1)->right = arg2;
69137 }
69138
69139
69140 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
69141   float jresult ;
69142   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69143   float result;
69144
69145   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69146   result = (float) ((arg1)->right);
69147   jresult = result;
69148   return jresult;
69149 }
69150
69151
69152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
69153   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69154   float arg2 ;
69155
69156   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69157   arg2 = (float)jarg2;
69158   if (arg1) (arg1)->top = arg2;
69159 }
69160
69161
69162 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
69163   float jresult ;
69164   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69165   float result;
69166
69167   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69168   result = (float) ((arg1)->top);
69169   jresult = result;
69170   return jresult;
69171 }
69172
69173
69174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
69175   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69176   float arg2 ;
69177
69178   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69179   arg2 = (float)jarg2;
69180   if (arg1) (arg1)->bottom = arg2;
69181 }
69182
69183
69184 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
69185   float jresult ;
69186   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69187   float result;
69188
69189   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69190   result = (float) ((arg1)->bottom);
69191   jresult = result;
69192   return jresult;
69193 }
69194
69195
69196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
69197   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69198
69199   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69200   {
69201     try {
69202       delete arg1;
69203     } catch (std::out_of_range& e) {
69204       {
69205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69206       };
69207     } catch (std::exception& e) {
69208       {
69209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69210       };
69211     } catch (Dali::DaliException e) {
69212       {
69213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69214       };
69215     } catch (...) {
69216       {
69217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69218       };
69219     }
69220   }
69221
69222 }
69223
69224
69225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
69226   void * jresult ;
69227   Dali::Toolkit::Alignment *result = 0 ;
69228
69229   {
69230     try {
69231       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
69232     } catch (std::out_of_range& e) {
69233       {
69234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69235       };
69236     } catch (std::exception& e) {
69237       {
69238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69239       };
69240     } catch (Dali::DaliException e) {
69241       {
69242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69243       };
69244     } catch (...) {
69245       {
69246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69247       };
69248     }
69249   }
69250
69251   jresult = (void *)result;
69252   return jresult;
69253 }
69254
69255
69256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
69257   void * jresult ;
69258   Dali::Toolkit::Alignment::Type arg1 ;
69259   Dali::Toolkit::Alignment::Type arg2 ;
69260   Dali::Toolkit::Alignment result;
69261
69262   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69263   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69264   {
69265     try {
69266       result = Dali::Toolkit::Alignment::New(arg1,arg2);
69267     } catch (std::out_of_range& e) {
69268       {
69269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69270       };
69271     } catch (std::exception& e) {
69272       {
69273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69274       };
69275     } catch (Dali::DaliException e) {
69276       {
69277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69278       };
69279     } catch (...) {
69280       {
69281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69282       };
69283     }
69284   }
69285
69286   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69287   return jresult;
69288 }
69289
69290
69291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
69292   void * jresult ;
69293   Dali::Toolkit::Alignment::Type arg1 ;
69294   Dali::Toolkit::Alignment result;
69295
69296   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69297   {
69298     try {
69299       result = Dali::Toolkit::Alignment::New(arg1);
69300     } catch (std::out_of_range& e) {
69301       {
69302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69303       };
69304     } catch (std::exception& e) {
69305       {
69306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69307       };
69308     } catch (Dali::DaliException e) {
69309       {
69310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69311       };
69312     } catch (...) {
69313       {
69314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69315       };
69316     }
69317   }
69318
69319   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69320   return jresult;
69321 }
69322
69323
69324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
69325   void * jresult ;
69326   Dali::Toolkit::Alignment result;
69327
69328   {
69329     try {
69330       result = Dali::Toolkit::Alignment::New();
69331     } catch (std::out_of_range& e) {
69332       {
69333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69334       };
69335     } catch (std::exception& e) {
69336       {
69337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69338       };
69339     } catch (Dali::DaliException e) {
69340       {
69341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69342       };
69343     } catch (...) {
69344       {
69345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69346       };
69347     }
69348   }
69349
69350   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69351   return jresult;
69352 }
69353
69354
69355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
69356   void * jresult ;
69357   Dali::Toolkit::Alignment *arg1 = 0 ;
69358   Dali::Toolkit::Alignment *result = 0 ;
69359
69360   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69361   if (!arg1) {
69362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69363     return 0;
69364   }
69365   {
69366     try {
69367       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
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 = (void *)result;
69388   return jresult;
69389 }
69390
69391
69392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
69393   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69394
69395   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69396   {
69397     try {
69398       delete arg1;
69399     } catch (std::out_of_range& e) {
69400       {
69401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69402       };
69403     } catch (std::exception& e) {
69404       {
69405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69406       };
69407     } catch (Dali::DaliException e) {
69408       {
69409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69410       };
69411     } catch (...) {
69412       {
69413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69414       };
69415     }
69416   }
69417
69418 }
69419
69420
69421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
69422   void * jresult ;
69423   Dali::BaseHandle arg1 ;
69424   Dali::BaseHandle *argp1 ;
69425   Dali::Toolkit::Alignment result;
69426
69427   argp1 = (Dali::BaseHandle *)jarg1;
69428   if (!argp1) {
69429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69430     return 0;
69431   }
69432   arg1 = *argp1;
69433   {
69434     try {
69435       result = Dali::Toolkit::Alignment::DownCast(arg1);
69436     } catch (std::out_of_range& e) {
69437       {
69438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69439       };
69440     } catch (std::exception& e) {
69441       {
69442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69443       };
69444     } catch (Dali::DaliException e) {
69445       {
69446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69447       };
69448     } catch (...) {
69449       {
69450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69451       };
69452     }
69453   }
69454
69455   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69456   return jresult;
69457 }
69458
69459
69460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
69461   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69462   Dali::Toolkit::Alignment::Type arg2 ;
69463
69464   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69465   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69466   {
69467     try {
69468       (arg1)->SetAlignmentType(arg2);
69469     } catch (std::out_of_range& e) {
69470       {
69471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69472       };
69473     } catch (std::exception& e) {
69474       {
69475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69476       };
69477     } catch (Dali::DaliException e) {
69478       {
69479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69480       };
69481     } catch (...) {
69482       {
69483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69484       };
69485     }
69486   }
69487
69488 }
69489
69490
69491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
69492   int jresult ;
69493   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69494   Dali::Toolkit::Alignment::Type result;
69495
69496   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69497   {
69498     try {
69499       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
69500     } catch (std::out_of_range& e) {
69501       {
69502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69503       };
69504     } catch (std::exception& e) {
69505       {
69506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69507       };
69508     } catch (Dali::DaliException e) {
69509       {
69510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69511       };
69512     } catch (...) {
69513       {
69514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69515       };
69516     }
69517   }
69518
69519   jresult = (int)result;
69520   return jresult;
69521 }
69522
69523
69524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
69525   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69526   Dali::Toolkit::Alignment::Scaling arg2 ;
69527
69528   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69529   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69530   {
69531     try {
69532       (arg1)->SetScaling(arg2);
69533     } catch (std::out_of_range& e) {
69534       {
69535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69536       };
69537     } catch (std::exception& e) {
69538       {
69539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69540       };
69541     } catch (Dali::DaliException e) {
69542       {
69543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69544       };
69545     } catch (...) {
69546       {
69547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69548       };
69549     }
69550   }
69551
69552 }
69553
69554
69555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69556   int jresult ;
69557   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69558   Dali::Toolkit::Alignment::Scaling result;
69559
69560   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69561   {
69562     try {
69563       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69564     } catch (std::out_of_range& e) {
69565       {
69566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69567       };
69568     } catch (std::exception& e) {
69569       {
69570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69571       };
69572     } catch (Dali::DaliException e) {
69573       {
69574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69575       };
69576     } catch (...) {
69577       {
69578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69579       };
69580     }
69581   }
69582
69583   jresult = (int)result;
69584   return jresult;
69585 }
69586
69587
69588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69589   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69590   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69591
69592   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69593   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69594   if (!arg2) {
69595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69596     return ;
69597   }
69598   {
69599     try {
69600       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69601     } catch (std::out_of_range& e) {
69602       {
69603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69604       };
69605     } catch (std::exception& e) {
69606       {
69607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69608       };
69609     } catch (Dali::DaliException e) {
69610       {
69611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69612       };
69613     } catch (...) {
69614       {
69615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69616       };
69617     }
69618   }
69619
69620 }
69621
69622
69623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69624   void * jresult ;
69625   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69626   Dali::Toolkit::Alignment::Padding *result = 0 ;
69627
69628   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69629   {
69630     try {
69631       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69632     } catch (std::out_of_range& e) {
69633       {
69634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69635       };
69636     } catch (std::exception& e) {
69637       {
69638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69639       };
69640     } catch (Dali::DaliException e) {
69641       {
69642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69643       };
69644     } catch (...) {
69645       {
69646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69647       };
69648     }
69649   }
69650
69651   jresult = (void *)result;
69652   return jresult;
69653 }
69654
69655
69656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69657   void * jresult ;
69658   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69659   Dali::Toolkit::Alignment *arg2 = 0 ;
69660   Dali::Toolkit::Alignment *result = 0 ;
69661
69662   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69663   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69664   if (!arg2) {
69665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69666     return 0;
69667   }
69668   {
69669     try {
69670       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69671     } catch (std::out_of_range& e) {
69672       {
69673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69674       };
69675     } catch (std::exception& e) {
69676       {
69677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69678       };
69679     } catch (Dali::DaliException e) {
69680       {
69681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69682       };
69683     } catch (...) {
69684       {
69685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69686       };
69687     }
69688   }
69689
69690   jresult = (void *)result;
69691   return jresult;
69692 }
69693
69694
69695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69696   int jresult ;
69697   int result;
69698
69699   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69700   jresult = (int)result;
69701   return jresult;
69702 }
69703
69704
69705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69706   int jresult ;
69707   int result;
69708
69709   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69710   jresult = (int)result;
69711   return jresult;
69712 }
69713
69714
69715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69716   int jresult ;
69717   int result;
69718
69719   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69720   jresult = (int)result;
69721   return jresult;
69722 }
69723
69724
69725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69726   int jresult ;
69727   int result;
69728
69729   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69730   jresult = (int)result;
69731   return jresult;
69732 }
69733
69734
69735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69736   int jresult ;
69737   int result;
69738
69739   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69740   jresult = (int)result;
69741   return jresult;
69742 }
69743
69744
69745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69746   int jresult ;
69747   int result;
69748
69749   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69750   jresult = (int)result;
69751   return jresult;
69752 }
69753
69754
69755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69756   int jresult ;
69757   int result;
69758
69759   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69760   jresult = (int)result;
69761   return jresult;
69762 }
69763
69764
69765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69766   int jresult ;
69767   int result;
69768
69769   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69770   jresult = (int)result;
69771   return jresult;
69772 }
69773
69774
69775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69776   int jresult ;
69777   int result;
69778
69779   result = (int)Dali::Toolkit::Button::Property::LABEL;
69780   jresult = (int)result;
69781   return jresult;
69782 }
69783
69784
69785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69786   int jresult ;
69787   int result;
69788
69789   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69790   jresult = (int)result;
69791   return jresult;
69792 }
69793
69794
69795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69796   void * jresult ;
69797   Dali::Toolkit::Button::Property *result = 0 ;
69798
69799   {
69800     try {
69801       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69802     } catch (std::out_of_range& e) {
69803       {
69804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69805       };
69806     } catch (std::exception& e) {
69807       {
69808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69809       };
69810     } catch (Dali::DaliException e) {
69811       {
69812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69813       };
69814     } catch (...) {
69815       {
69816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69817       };
69818     }
69819   }
69820
69821   jresult = (void *)result;
69822   return jresult;
69823 }
69824
69825
69826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69827   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69828
69829   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69830   {
69831     try {
69832       delete arg1;
69833     } catch (std::out_of_range& e) {
69834       {
69835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69836       };
69837     } catch (std::exception& e) {
69838       {
69839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69840       };
69841     } catch (Dali::DaliException e) {
69842       {
69843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69844       };
69845     } catch (...) {
69846       {
69847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69848       };
69849     }
69850   }
69851
69852 }
69853
69854
69855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69856   void * jresult ;
69857   Dali::Toolkit::Button *result = 0 ;
69858
69859   {
69860     try {
69861       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69862     } catch (std::out_of_range& e) {
69863       {
69864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69865       };
69866     } catch (std::exception& e) {
69867       {
69868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69869       };
69870     } catch (Dali::DaliException e) {
69871       {
69872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69873       };
69874     } catch (...) {
69875       {
69876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69877       };
69878     }
69879   }
69880
69881   jresult = (void *)result;
69882   return jresult;
69883 }
69884
69885
69886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69887   void * jresult ;
69888   Dali::Toolkit::Button *arg1 = 0 ;
69889   Dali::Toolkit::Button *result = 0 ;
69890
69891   arg1 = (Dali::Toolkit::Button *)jarg1;
69892   if (!arg1) {
69893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69894     return 0;
69895   }
69896   {
69897     try {
69898       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
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_Button_Assign(void * jarg1, void * jarg2) {
69924   void * jresult ;
69925   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69926   Dali::Toolkit::Button *arg2 = 0 ;
69927   Dali::Toolkit::Button *result = 0 ;
69928
69929   arg1 = (Dali::Toolkit::Button *)jarg1;
69930   arg2 = (Dali::Toolkit::Button *)jarg2;
69931   if (!arg2) {
69932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69933     return 0;
69934   }
69935   {
69936     try {
69937       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69938     } catch (std::out_of_range& e) {
69939       {
69940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69941       };
69942     } catch (std::exception& e) {
69943       {
69944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69945       };
69946     } catch (Dali::DaliException e) {
69947       {
69948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69949       };
69950     } catch (...) {
69951       {
69952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69953       };
69954     }
69955   }
69956
69957   jresult = (void *)result;
69958   return jresult;
69959 }
69960
69961
69962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69963   void * jresult ;
69964   Dali::BaseHandle arg1 ;
69965   Dali::BaseHandle *argp1 ;
69966   Dali::Toolkit::Button result;
69967
69968   argp1 = (Dali::BaseHandle *)jarg1;
69969   if (!argp1) {
69970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69971     return 0;
69972   }
69973   arg1 = *argp1;
69974   {
69975     try {
69976       result = Dali::Toolkit::Button::DownCast(arg1);
69977     } catch (std::out_of_range& e) {
69978       {
69979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69980       };
69981     } catch (std::exception& e) {
69982       {
69983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69984       };
69985     } catch (Dali::DaliException e) {
69986       {
69987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69988       };
69989     } catch (...) {
69990       {
69991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69992       };
69993     }
69994   }
69995
69996   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69997   return jresult;
69998 }
69999
70000
70001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
70002   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70003
70004   arg1 = (Dali::Toolkit::Button *)jarg1;
70005   {
70006     try {
70007       delete arg1;
70008     } catch (std::out_of_range& e) {
70009       {
70010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70011       };
70012     } catch (std::exception& e) {
70013       {
70014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70015       };
70016     } catch (Dali::DaliException e) {
70017       {
70018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70019       };
70020     } catch (...) {
70021       {
70022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70023       };
70024     }
70025   }
70026
70027 }
70028
70029
70030 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
70031   unsigned int jresult ;
70032   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70033   bool result;
70034
70035   arg1 = (Dali::Toolkit::Button *)jarg1;
70036   {
70037     try {
70038       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
70039     } catch (std::out_of_range& e) {
70040       {
70041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70042       };
70043     } catch (std::exception& e) {
70044       {
70045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70046       };
70047     } catch (Dali::DaliException e) {
70048       {
70049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70050       };
70051     } catch (...) {
70052       {
70053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70054       };
70055     }
70056   }
70057
70058   jresult = result;
70059   return jresult;
70060 }
70061
70062
70063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
70064   unsigned int jresult ;
70065   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70066   bool result;
70067
70068   arg1 = (Dali::Toolkit::Button *)jarg1;
70069   {
70070     try {
70071       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
70072     } catch (std::out_of_range& e) {
70073       {
70074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70075       };
70076     } catch (std::exception& e) {
70077       {
70078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70079       };
70080     } catch (Dali::DaliException e) {
70081       {
70082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70083       };
70084     } catch (...) {
70085       {
70086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70087       };
70088     }
70089   }
70090
70091   jresult = result;
70092   return jresult;
70093 }
70094
70095
70096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
70097   float jresult ;
70098   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70099   float result;
70100
70101   arg1 = (Dali::Toolkit::Button *)jarg1;
70102   {
70103     try {
70104       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
70105     } catch (std::out_of_range& e) {
70106       {
70107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70108       };
70109     } catch (std::exception& e) {
70110       {
70111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70112       };
70113     } catch (Dali::DaliException e) {
70114       {
70115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70116       };
70117     } catch (...) {
70118       {
70119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70120       };
70121     }
70122   }
70123
70124   jresult = result;
70125   return jresult;
70126 }
70127
70128
70129 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
70130   float jresult ;
70131   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70132   float result;
70133
70134   arg1 = (Dali::Toolkit::Button *)jarg1;
70135   {
70136     try {
70137       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
70138     } catch (std::out_of_range& e) {
70139       {
70140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70141       };
70142     } catch (std::exception& e) {
70143       {
70144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70145       };
70146     } catch (Dali::DaliException e) {
70147       {
70148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70149       };
70150     } catch (...) {
70151       {
70152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70153       };
70154     }
70155   }
70156
70157   jresult = result;
70158   return jresult;
70159 }
70160
70161
70162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
70163   unsigned int jresult ;
70164   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70165   bool result;
70166
70167   arg1 = (Dali::Toolkit::Button *)jarg1;
70168   {
70169     try {
70170       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
70171     } catch (std::out_of_range& e) {
70172       {
70173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70174       };
70175     } catch (std::exception& e) {
70176       {
70177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70178       };
70179     } catch (Dali::DaliException e) {
70180       {
70181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70182       };
70183     } catch (...) {
70184       {
70185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70186       };
70187     }
70188   }
70189
70190   jresult = result;
70191   return jresult;
70192 }
70193
70194
70195 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
70196   unsigned int jresult ;
70197   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70198   bool result;
70199
70200   arg1 = (Dali::Toolkit::Button *)jarg1;
70201   {
70202     try {
70203       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
70204     } catch (std::out_of_range& e) {
70205       {
70206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70207       };
70208     } catch (std::exception& e) {
70209       {
70210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70211       };
70212     } catch (Dali::DaliException e) {
70213       {
70214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70215       };
70216     } catch (...) {
70217       {
70218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70219       };
70220     }
70221   }
70222
70223   jresult = result;
70224   return jresult;
70225 }
70226
70227
70228 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
70229   float jresult ;
70230   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70231   float result;
70232
70233   arg1 = (Dali::Toolkit::Button *)jarg1;
70234   {
70235     try {
70236       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
70237     } catch (std::out_of_range& e) {
70238       {
70239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70240       };
70241     } catch (std::exception& e) {
70242       {
70243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70244       };
70245     } catch (Dali::DaliException e) {
70246       {
70247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70248       };
70249     } catch (...) {
70250       {
70251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70252       };
70253     }
70254   }
70255
70256   jresult = result;
70257   return jresult;
70258 }
70259
70260
70261 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
70262   char * jresult ;
70263   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70264   std::string result;
70265
70266   arg1 = (Dali::Toolkit::Button *)jarg1;
70267   {
70268     try {
70269       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
70270     } catch (std::out_of_range& e) {
70271       {
70272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70273       };
70274     } catch (std::exception& e) {
70275       {
70276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70277       };
70278     } catch (Dali::DaliException e) {
70279       {
70280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70281       };
70282     } catch (...) {
70283       {
70284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70285       };
70286     }
70287   }
70288
70289   jresult = SWIG_csharp_string_callback((&result)->c_str());
70290   return jresult;
70291 }
70292
70293
70294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
70295   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70296   Dali::Actor arg2 ;
70297   Dali::Actor *argp2 ;
70298
70299   arg1 = (Dali::Toolkit::Button *)jarg1;
70300   argp2 = (Dali::Actor *)jarg2;
70301   if (!argp2) {
70302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70303     return ;
70304   }
70305   arg2 = *argp2;
70306   {
70307     try {
70308       (arg1)->SetLabel(arg2);
70309     } catch (std::out_of_range& e) {
70310       {
70311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70312       };
70313     } catch (std::exception& e) {
70314       {
70315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70316       };
70317     } catch (Dali::DaliException e) {
70318       {
70319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70320       };
70321     } catch (...) {
70322       {
70323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70324       };
70325     }
70326   }
70327
70328 }
70329
70330
70331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
70332   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70333   Dali::Image arg2 ;
70334   Dali::Image *argp2 ;
70335
70336   arg1 = (Dali::Toolkit::Button *)jarg1;
70337   argp2 = (Dali::Image *)jarg2;
70338   if (!argp2) {
70339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70340     return ;
70341   }
70342   arg2 = *argp2;
70343   {
70344     try {
70345       (arg1)->SetButtonImage(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_SetSelectedImage(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)->SetSelectedImage(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_GetButtonImage(void * jarg1) {
70406   void * jresult ;
70407   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70408   Dali::Actor result;
70409
70410   arg1 = (Dali::Toolkit::Button *)jarg1;
70411   {
70412     try {
70413       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
70414     } catch (std::out_of_range& e) {
70415       {
70416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70417       };
70418     } catch (std::exception& e) {
70419       {
70420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70421       };
70422     } catch (Dali::DaliException e) {
70423       {
70424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70425       };
70426     } catch (...) {
70427       {
70428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70429       };
70430     }
70431   }
70432
70433   jresult = new Dali::Actor((const Dali::Actor &)result);
70434   return jresult;
70435 }
70436
70437
70438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
70439   void * jresult ;
70440   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70441   Dali::Actor result;
70442
70443   arg1 = (Dali::Toolkit::Button *)jarg1;
70444   {
70445     try {
70446       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
70447     } catch (std::out_of_range& e) {
70448       {
70449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70450       };
70451     } catch (std::exception& e) {
70452       {
70453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70454       };
70455     } catch (Dali::DaliException e) {
70456       {
70457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70458       };
70459     } catch (...) {
70460       {
70461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70462       };
70463     }
70464   }
70465
70466   jresult = new Dali::Actor((const Dali::Actor &)result);
70467   return jresult;
70468 }
70469
70470
70471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
70472   void * jresult ;
70473   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70474   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70475
70476   arg1 = (Dali::Toolkit::Button *)jarg1;
70477   {
70478     try {
70479       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
70480     } catch (std::out_of_range& e) {
70481       {
70482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70483       };
70484     } catch (std::exception& e) {
70485       {
70486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70487       };
70488     } catch (Dali::DaliException e) {
70489       {
70490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70491       };
70492     } catch (...) {
70493       {
70494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70495       };
70496     }
70497   }
70498
70499   jresult = (void *)result;
70500   return jresult;
70501 }
70502
70503
70504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70505   void * jresult ;
70506   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70507   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70508
70509   arg1 = (Dali::Toolkit::Button *)jarg1;
70510   {
70511     try {
70512       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70513     } catch (std::out_of_range& e) {
70514       {
70515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70516       };
70517     } catch (std::exception& e) {
70518       {
70519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70520       };
70521     } catch (Dali::DaliException e) {
70522       {
70523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70524       };
70525     } catch (...) {
70526       {
70527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70528       };
70529     }
70530   }
70531
70532   jresult = (void *)result;
70533   return jresult;
70534 }
70535
70536
70537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70538   void * jresult ;
70539   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70540   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70541
70542   arg1 = (Dali::Toolkit::Button *)jarg1;
70543   {
70544     try {
70545       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
70546     } catch (std::out_of_range& e) {
70547       {
70548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70549       };
70550     } catch (std::exception& e) {
70551       {
70552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70553       };
70554     } catch (Dali::DaliException e) {
70555       {
70556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70557       };
70558     } catch (...) {
70559       {
70560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70561       };
70562     }
70563   }
70564
70565   jresult = (void *)result;
70566   return jresult;
70567 }
70568
70569
70570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70571   void * jresult ;
70572   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70573   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70574
70575   arg1 = (Dali::Toolkit::Button *)jarg1;
70576   {
70577     try {
70578       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70579     } catch (std::out_of_range& e) {
70580       {
70581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70582       };
70583     } catch (std::exception& e) {
70584       {
70585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70586       };
70587     } catch (Dali::DaliException e) {
70588       {
70589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70590       };
70591     } catch (...) {
70592       {
70593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70594       };
70595     }
70596   }
70597
70598   jresult = (void *)result;
70599   return jresult;
70600 }
70601
70602
70603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70604   void * jresult ;
70605   Dali::Toolkit::CheckBoxButton *result = 0 ;
70606
70607   {
70608     try {
70609       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70610     } catch (std::out_of_range& e) {
70611       {
70612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70613       };
70614     } catch (std::exception& e) {
70615       {
70616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70617       };
70618     } catch (Dali::DaliException e) {
70619       {
70620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70621       };
70622     } catch (...) {
70623       {
70624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70625       };
70626     }
70627   }
70628
70629   jresult = (void *)result;
70630   return jresult;
70631 }
70632
70633
70634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70635   void * jresult ;
70636   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70637   Dali::Toolkit::CheckBoxButton *result = 0 ;
70638
70639   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70640   if (!arg1) {
70641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70642     return 0;
70643   }
70644   {
70645     try {
70646       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
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_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70672   void * jresult ;
70673   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70674   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70675   Dali::Toolkit::CheckBoxButton *result = 0 ;
70676
70677   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70678   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70679   if (!arg2) {
70680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70681     return 0;
70682   }
70683   {
70684     try {
70685       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70686     } catch (std::out_of_range& e) {
70687       {
70688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70689       };
70690     } catch (std::exception& e) {
70691       {
70692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70693       };
70694     } catch (Dali::DaliException e) {
70695       {
70696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70697       };
70698     } catch (...) {
70699       {
70700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70701       };
70702     }
70703   }
70704
70705   jresult = (void *)result;
70706   return jresult;
70707 }
70708
70709
70710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70711   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70712
70713   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70714   {
70715     try {
70716       delete arg1;
70717     } catch (std::out_of_range& e) {
70718       {
70719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70720       };
70721     } catch (std::exception& e) {
70722       {
70723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70724       };
70725     } catch (Dali::DaliException e) {
70726       {
70727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70728       };
70729     } catch (...) {
70730       {
70731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70732       };
70733     }
70734   }
70735
70736 }
70737
70738
70739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70740   void * jresult ;
70741   Dali::Toolkit::CheckBoxButton result;
70742
70743   {
70744     try {
70745       result = Dali::Toolkit::CheckBoxButton::New();
70746     } catch (std::out_of_range& e) {
70747       {
70748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70749       };
70750     } catch (std::exception& e) {
70751       {
70752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70753       };
70754     } catch (Dali::DaliException e) {
70755       {
70756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70757       };
70758     } catch (...) {
70759       {
70760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70761       };
70762     }
70763   }
70764
70765   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70766   return jresult;
70767 }
70768
70769
70770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70771   void * jresult ;
70772   Dali::BaseHandle arg1 ;
70773   Dali::BaseHandle *argp1 ;
70774   Dali::Toolkit::CheckBoxButton result;
70775
70776   argp1 = (Dali::BaseHandle *)jarg1;
70777   if (!argp1) {
70778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70779     return 0;
70780   }
70781   arg1 = *argp1;
70782   {
70783     try {
70784       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70785     } catch (std::out_of_range& e) {
70786       {
70787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70788       };
70789     } catch (std::exception& e) {
70790       {
70791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70792       };
70793     } catch (Dali::DaliException e) {
70794       {
70795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70796       };
70797     } catch (...) {
70798       {
70799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70800       };
70801     }
70802   }
70803
70804   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70805   return jresult;
70806 }
70807
70808
70809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70810   int jresult ;
70811   int result;
70812
70813   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70814   jresult = (int)result;
70815   return jresult;
70816 }
70817
70818
70819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70820   int jresult ;
70821   int result;
70822
70823   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70824   jresult = (int)result;
70825   return jresult;
70826 }
70827
70828
70829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70830   int jresult ;
70831   int result;
70832
70833   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70834   jresult = (int)result;
70835   return jresult;
70836 }
70837
70838
70839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70840   int jresult ;
70841   int result;
70842
70843   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70844   jresult = (int)result;
70845   return jresult;
70846 }
70847
70848
70849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70850   int jresult ;
70851   int result;
70852
70853   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70854   jresult = (int)result;
70855   return jresult;
70856 }
70857
70858
70859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70860   void * jresult ;
70861   Dali::Toolkit::PushButton::Property *result = 0 ;
70862
70863   {
70864     try {
70865       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70866     } catch (std::out_of_range& e) {
70867       {
70868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70869       };
70870     } catch (std::exception& e) {
70871       {
70872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70873       };
70874     } catch (Dali::DaliException e) {
70875       {
70876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70877       };
70878     } catch (...) {
70879       {
70880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70881       };
70882     }
70883   }
70884
70885   jresult = (void *)result;
70886   return jresult;
70887 }
70888
70889
70890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70891   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70892
70893   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70894   {
70895     try {
70896       delete arg1;
70897     } catch (std::out_of_range& e) {
70898       {
70899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70900       };
70901     } catch (std::exception& e) {
70902       {
70903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70904       };
70905     } catch (Dali::DaliException e) {
70906       {
70907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70908       };
70909     } catch (...) {
70910       {
70911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70912       };
70913     }
70914   }
70915
70916 }
70917
70918
70919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70920   void * jresult ;
70921   Dali::Toolkit::PushButton *result = 0 ;
70922
70923   {
70924     try {
70925       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70926     } catch (std::out_of_range& e) {
70927       {
70928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70929       };
70930     } catch (std::exception& e) {
70931       {
70932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70933       };
70934     } catch (Dali::DaliException e) {
70935       {
70936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70937       };
70938     } catch (...) {
70939       {
70940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70941       };
70942     }
70943   }
70944
70945   jresult = (void *)result;
70946   return jresult;
70947 }
70948
70949
70950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70951   void * jresult ;
70952   Dali::Toolkit::PushButton *arg1 = 0 ;
70953   Dali::Toolkit::PushButton *result = 0 ;
70954
70955   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70956   if (!arg1) {
70957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70958     return 0;
70959   }
70960   {
70961     try {
70962       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70963     } catch (std::out_of_range& e) {
70964       {
70965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70966       };
70967     } catch (std::exception& e) {
70968       {
70969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70970       };
70971     } catch (Dali::DaliException e) {
70972       {
70973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70974       };
70975     } catch (...) {
70976       {
70977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70978       };
70979     }
70980   }
70981
70982   jresult = (void *)result;
70983   return jresult;
70984 }
70985
70986
70987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70988   void * jresult ;
70989   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70990   Dali::Toolkit::PushButton *arg2 = 0 ;
70991   Dali::Toolkit::PushButton *result = 0 ;
70992
70993   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70994   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70995   if (!arg2) {
70996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70997     return 0;
70998   }
70999   {
71000     try {
71001       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
71002     } catch (std::out_of_range& e) {
71003       {
71004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71005       };
71006     } catch (std::exception& e) {
71007       {
71008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71009       };
71010     } catch (Dali::DaliException e) {
71011       {
71012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71013       };
71014     } catch (...) {
71015       {
71016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71017       };
71018     }
71019   }
71020
71021   jresult = (void *)result;
71022   return jresult;
71023 }
71024
71025
71026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
71027   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71028
71029   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71030   {
71031     try {
71032       delete arg1;
71033     } catch (std::out_of_range& e) {
71034       {
71035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71036       };
71037     } catch (std::exception& e) {
71038       {
71039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71040       };
71041     } catch (Dali::DaliException e) {
71042       {
71043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71044       };
71045     } catch (...) {
71046       {
71047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71048       };
71049     }
71050   }
71051
71052 }
71053
71054
71055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
71056   void * jresult ;
71057   Dali::Toolkit::PushButton result;
71058
71059   {
71060     try {
71061       result = Dali::Toolkit::PushButton::New();
71062     } catch (std::out_of_range& e) {
71063       {
71064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71065       };
71066     } catch (std::exception& e) {
71067       {
71068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71069       };
71070     } catch (Dali::DaliException e) {
71071       {
71072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71073       };
71074     } catch (...) {
71075       {
71076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71077       };
71078     }
71079   }
71080
71081   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
71082   return jresult;
71083 }
71084
71085
71086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
71087   void * jresult ;
71088   Dali::BaseHandle arg1 ;
71089   Dali::BaseHandle *argp1 ;
71090   Dali::Toolkit::PushButton result;
71091
71092   argp1 = (Dali::BaseHandle *)jarg1;
71093   if (!argp1) {
71094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71095     return 0;
71096   }
71097   arg1 = *argp1;
71098   {
71099     try {
71100       result = Dali::Toolkit::PushButton::DownCast(arg1);
71101     } catch (std::out_of_range& e) {
71102       {
71103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71104       };
71105     } catch (std::exception& e) {
71106       {
71107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71108       };
71109     } catch (Dali::DaliException e) {
71110       {
71111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71112       };
71113     } catch (...) {
71114       {
71115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71116       };
71117     }
71118   }
71119
71120   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
71121   return jresult;
71122 }
71123
71124
71125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
71126   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71127   Dali::Image arg2 ;
71128   Dali::Image *argp2 ;
71129
71130   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71131   argp2 = (Dali::Image *)jarg2;
71132   if (!argp2) {
71133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71134     return ;
71135   }
71136   arg2 = *argp2;
71137   {
71138     try {
71139       (arg1)->SetButtonImage(arg2);
71140     } catch (std::out_of_range& e) {
71141       {
71142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71143       };
71144     } catch (std::exception& e) {
71145       {
71146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71147       };
71148     } catch (Dali::DaliException e) {
71149       {
71150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71151       };
71152     } catch (...) {
71153       {
71154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71155       };
71156     }
71157   }
71158
71159 }
71160
71161
71162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
71163   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71164   Dali::Actor arg2 ;
71165   Dali::Actor *argp2 ;
71166
71167   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71168   argp2 = (Dali::Actor *)jarg2;
71169   if (!argp2) {
71170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 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_SetBackgroundImage(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)->SetBackgroundImage(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_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
71237   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71238   Dali::Image arg2 ;
71239   Dali::Image *argp2 ;
71240
71241   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71242   argp2 = (Dali::Image *)jarg2;
71243   if (!argp2) {
71244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71245     return ;
71246   }
71247   arg2 = *argp2;
71248   {
71249     try {
71250       (arg1)->SetSelectedImage(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_1(void * jarg1, void * jarg2) {
71274   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71275   Dali::Actor arg2 ;
71276   Dali::Actor *argp2 ;
71277
71278   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71279   argp2 = (Dali::Actor *)jarg2;
71280   if (!argp2) {
71281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 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_SetSelectedBackgroundImage(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)->SetSelectedBackgroundImage(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_SetDisabledBackgroundImage(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)->SetDisabledBackgroundImage(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_SetDisabledImage(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)->SetDisabledImage(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_SetDisabledSelectedImage(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)->SetDisabledSelectedImage(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_new_RadioButton__SWIG_0() {
71459   void * jresult ;
71460   Dali::Toolkit::RadioButton *result = 0 ;
71461
71462   {
71463     try {
71464       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
71465     } catch (std::out_of_range& e) {
71466       {
71467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71468       };
71469     } catch (std::exception& e) {
71470       {
71471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71472       };
71473     } catch (Dali::DaliException e) {
71474       {
71475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71476       };
71477     } catch (...) {
71478       {
71479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71480       };
71481     }
71482   }
71483
71484   jresult = (void *)result;
71485   return jresult;
71486 }
71487
71488
71489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
71490   void * jresult ;
71491   Dali::Toolkit::RadioButton *arg1 = 0 ;
71492   Dali::Toolkit::RadioButton *result = 0 ;
71493
71494   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71495   if (!arg1) {
71496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71497     return 0;
71498   }
71499   {
71500     try {
71501       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
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_RadioButton_Assign(void * jarg1, void * jarg2) {
71527   void * jresult ;
71528   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71529   Dali::Toolkit::RadioButton *arg2 = 0 ;
71530   Dali::Toolkit::RadioButton *result = 0 ;
71531
71532   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71533   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71534   if (!arg2) {
71535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71536     return 0;
71537   }
71538   {
71539     try {
71540       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
71541     } catch (std::out_of_range& e) {
71542       {
71543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71544       };
71545     } catch (std::exception& e) {
71546       {
71547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71548       };
71549     } catch (Dali::DaliException e) {
71550       {
71551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71552       };
71553     } catch (...) {
71554       {
71555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71556       };
71557     }
71558   }
71559
71560   jresult = (void *)result;
71561   return jresult;
71562 }
71563
71564
71565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71566   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71567
71568   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71569   {
71570     try {
71571       delete arg1;
71572     } catch (std::out_of_range& e) {
71573       {
71574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71575       };
71576     } catch (std::exception& e) {
71577       {
71578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71579       };
71580     } catch (Dali::DaliException e) {
71581       {
71582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71583       };
71584     } catch (...) {
71585       {
71586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71587       };
71588     }
71589   }
71590
71591 }
71592
71593
71594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71595   void * jresult ;
71596   Dali::Toolkit::RadioButton result;
71597
71598   {
71599     try {
71600       result = Dali::Toolkit::RadioButton::New();
71601     } catch (std::out_of_range& e) {
71602       {
71603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71604       };
71605     } catch (std::exception& e) {
71606       {
71607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71608       };
71609     } catch (Dali::DaliException e) {
71610       {
71611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71612       };
71613     } catch (...) {
71614       {
71615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71616       };
71617     }
71618   }
71619
71620   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71621   return jresult;
71622 }
71623
71624
71625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71626   void * jresult ;
71627   std::string *arg1 = 0 ;
71628   Dali::Toolkit::RadioButton result;
71629
71630   if (!jarg1) {
71631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71632     return 0;
71633   }
71634   std::string arg1_str(jarg1);
71635   arg1 = &arg1_str;
71636   {
71637     try {
71638       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71639     } catch (std::out_of_range& e) {
71640       {
71641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71642       };
71643     } catch (std::exception& e) {
71644       {
71645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71646       };
71647     } catch (Dali::DaliException e) {
71648       {
71649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71650       };
71651     } catch (...) {
71652       {
71653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71654       };
71655     }
71656   }
71657
71658   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71659
71660   //argout typemap for const std::string&
71661
71662   return jresult;
71663 }
71664
71665
71666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71667   void * jresult ;
71668   Dali::BaseHandle arg1 ;
71669   Dali::BaseHandle *argp1 ;
71670   Dali::Toolkit::RadioButton result;
71671
71672   argp1 = (Dali::BaseHandle *)jarg1;
71673   if (!argp1) {
71674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71675     return 0;
71676   }
71677   arg1 = *argp1;
71678   {
71679     try {
71680       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71681     } catch (std::out_of_range& e) {
71682       {
71683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71684       };
71685     } catch (std::exception& e) {
71686       {
71687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71688       };
71689     } catch (Dali::DaliException e) {
71690       {
71691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71692       };
71693     } catch (...) {
71694       {
71695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71696       };
71697     }
71698   }
71699
71700   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71701   return jresult;
71702 }
71703
71704
71705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71706   int jresult ;
71707   int result;
71708
71709   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71710   jresult = (int)result;
71711   return jresult;
71712 }
71713
71714
71715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71716   int jresult ;
71717   int result;
71718
71719   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71720   jresult = (int)result;
71721   return jresult;
71722 }
71723
71724
71725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71726   int jresult ;
71727   int result;
71728
71729   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71730   jresult = (int)result;
71731   return jresult;
71732 }
71733
71734
71735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71736   int jresult ;
71737   int result;
71738
71739   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71740   jresult = (int)result;
71741   return jresult;
71742 }
71743
71744
71745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71746   int jresult ;
71747   int result;
71748
71749   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71750   jresult = (int)result;
71751   return jresult;
71752 }
71753
71754
71755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71756   int jresult ;
71757   int result;
71758
71759   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71760   jresult = (int)result;
71761   return jresult;
71762 }
71763
71764
71765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71766   void * jresult ;
71767   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71768
71769   {
71770     try {
71771       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71772     } catch (std::out_of_range& e) {
71773       {
71774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71775       };
71776     } catch (std::exception& e) {
71777       {
71778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71779       };
71780     } catch (Dali::DaliException e) {
71781       {
71782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71783       };
71784     } catch (...) {
71785       {
71786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71787       };
71788     }
71789   }
71790
71791   jresult = (void *)result;
71792   return jresult;
71793 }
71794
71795
71796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71797   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71798
71799   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71800   {
71801     try {
71802       delete arg1;
71803     } catch (std::out_of_range& e) {
71804       {
71805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71806       };
71807     } catch (std::exception& e) {
71808       {
71809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71810       };
71811     } catch (Dali::DaliException e) {
71812       {
71813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71814       };
71815     } catch (...) {
71816       {
71817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71818       };
71819     }
71820   }
71821
71822 }
71823
71824
71825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71826   int jresult ;
71827   int result;
71828
71829   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71830   jresult = (int)result;
71831   return jresult;
71832 }
71833
71834
71835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71836   int jresult ;
71837   int result;
71838
71839   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71840   jresult = (int)result;
71841   return jresult;
71842 }
71843
71844
71845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71846   int jresult ;
71847   int result;
71848
71849   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71850   jresult = (int)result;
71851   return jresult;
71852 }
71853
71854
71855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71856   void * jresult ;
71857   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71858
71859   {
71860     try {
71861       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71862     } catch (std::out_of_range& e) {
71863       {
71864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71865       };
71866     } catch (std::exception& e) {
71867       {
71868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71869       };
71870     } catch (Dali::DaliException e) {
71871       {
71872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71873       };
71874     } catch (...) {
71875       {
71876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71877       };
71878     }
71879   }
71880
71881   jresult = (void *)result;
71882   return jresult;
71883 }
71884
71885
71886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71887   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71888
71889   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71890   {
71891     try {
71892       delete arg1;
71893     } catch (std::out_of_range& e) {
71894       {
71895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71896       };
71897     } catch (std::exception& e) {
71898       {
71899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71900       };
71901     } catch (Dali::DaliException e) {
71902       {
71903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71904       };
71905     } catch (...) {
71906       {
71907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71908       };
71909     }
71910   }
71911
71912 }
71913
71914
71915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71916   void * jresult ;
71917   Dali::Toolkit::FlexContainer *result = 0 ;
71918
71919   {
71920     try {
71921       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71922     } catch (std::out_of_range& e) {
71923       {
71924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71925       };
71926     } catch (std::exception& e) {
71927       {
71928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71929       };
71930     } catch (Dali::DaliException e) {
71931       {
71932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71933       };
71934     } catch (...) {
71935       {
71936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71937       };
71938     }
71939   }
71940
71941   jresult = (void *)result;
71942   return jresult;
71943 }
71944
71945
71946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71947   void * jresult ;
71948   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71949   Dali::Toolkit::FlexContainer *result = 0 ;
71950
71951   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71952   if (!arg1) {
71953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71954     return 0;
71955   }
71956   {
71957     try {
71958       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
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_FlexContainer_Assign(void * jarg1, void * jarg2) {
71984   void * jresult ;
71985   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71986   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71987   Dali::Toolkit::FlexContainer *result = 0 ;
71988
71989   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71990   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71991   if (!arg2) {
71992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71993     return 0;
71994   }
71995   {
71996     try {
71997       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71998     } catch (std::out_of_range& e) {
71999       {
72000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72001       };
72002     } catch (std::exception& e) {
72003       {
72004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72005       };
72006     } catch (Dali::DaliException e) {
72007       {
72008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72009       };
72010     } catch (...) {
72011       {
72012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72013       };
72014     }
72015   }
72016
72017   jresult = (void *)result;
72018   return jresult;
72019 }
72020
72021
72022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
72023   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
72024
72025   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
72026   {
72027     try {
72028       delete arg1;
72029     } catch (std::out_of_range& e) {
72030       {
72031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72032       };
72033     } catch (std::exception& e) {
72034       {
72035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72036       };
72037     } catch (Dali::DaliException e) {
72038       {
72039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72040       };
72041     } catch (...) {
72042       {
72043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72044       };
72045     }
72046   }
72047
72048 }
72049
72050
72051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
72052   void * jresult ;
72053   Dali::Toolkit::FlexContainer result;
72054
72055   {
72056     try {
72057       result = Dali::Toolkit::FlexContainer::New();
72058     } catch (std::out_of_range& e) {
72059       {
72060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72061       };
72062     } catch (std::exception& e) {
72063       {
72064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72065       };
72066     } catch (Dali::DaliException e) {
72067       {
72068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72069       };
72070     } catch (...) {
72071       {
72072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72073       };
72074     }
72075   }
72076
72077   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
72078   return jresult;
72079 }
72080
72081
72082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
72083   void * jresult ;
72084   Dali::BaseHandle arg1 ;
72085   Dali::BaseHandle *argp1 ;
72086   Dali::Toolkit::FlexContainer result;
72087
72088   argp1 = (Dali::BaseHandle *)jarg1;
72089   if (!argp1) {
72090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72091     return 0;
72092   }
72093   arg1 = *argp1;
72094   {
72095     try {
72096       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
72097     } catch (std::out_of_range& e) {
72098       {
72099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72100       };
72101     } catch (std::exception& e) {
72102       {
72103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72104       };
72105     } catch (Dali::DaliException e) {
72106       {
72107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72108       };
72109     } catch (...) {
72110       {
72111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72112       };
72113     }
72114   }
72115
72116   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
72117   return jresult;
72118 }
72119
72120
72121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
72122   int jresult ;
72123   int result;
72124
72125   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
72126   jresult = (int)result;
72127   return jresult;
72128 }
72129
72130
72131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
72132   int jresult ;
72133   int result;
72134
72135   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
72136   jresult = (int)result;
72137   return jresult;
72138 }
72139
72140
72141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
72142   int jresult ;
72143   int result;
72144
72145   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
72146   jresult = (int)result;
72147   return jresult;
72148 }
72149
72150
72151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
72152   int jresult ;
72153   int result;
72154
72155   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
72156   jresult = (int)result;
72157   return jresult;
72158 }
72159
72160
72161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
72162   void * jresult ;
72163   Dali::Toolkit::ImageView::Property *result = 0 ;
72164
72165   {
72166     try {
72167       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
72168     } catch (std::out_of_range& e) {
72169       {
72170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72171       };
72172     } catch (std::exception& e) {
72173       {
72174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72175       };
72176     } catch (Dali::DaliException e) {
72177       {
72178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72179       };
72180     } catch (...) {
72181       {
72182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72183       };
72184     }
72185   }
72186
72187   jresult = (void *)result;
72188   return jresult;
72189 }
72190
72191
72192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
72193   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
72194
72195   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
72196   {
72197     try {
72198       delete arg1;
72199     } catch (std::out_of_range& e) {
72200       {
72201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72202       };
72203     } catch (std::exception& e) {
72204       {
72205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72206       };
72207     } catch (Dali::DaliException e) {
72208       {
72209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72210       };
72211     } catch (...) {
72212       {
72213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72214       };
72215     }
72216   }
72217
72218 }
72219
72220
72221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
72222   void * jresult ;
72223   Dali::Toolkit::ImageView *result = 0 ;
72224
72225   {
72226     try {
72227       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
72228     } catch (std::out_of_range& e) {
72229       {
72230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72231       };
72232     } catch (std::exception& e) {
72233       {
72234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72235       };
72236     } catch (Dali::DaliException e) {
72237       {
72238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72239       };
72240     } catch (...) {
72241       {
72242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72243       };
72244     }
72245   }
72246
72247   jresult = (void *)result;
72248   return jresult;
72249 }
72250
72251
72252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
72253   void * jresult ;
72254   Dali::Toolkit::ImageView result;
72255
72256   {
72257     try {
72258       result = Dali::Toolkit::ImageView::New();
72259     } catch (std::out_of_range& e) {
72260       {
72261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72262       };
72263     } catch (std::exception& e) {
72264       {
72265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72266       };
72267     } catch (Dali::DaliException e) {
72268       {
72269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72270       };
72271     } catch (...) {
72272       {
72273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72274       };
72275     }
72276   }
72277
72278   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72279   return jresult;
72280 }
72281
72282
72283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
72284   void * jresult ;
72285   Dali::Image arg1 ;
72286   Dali::Image *argp1 ;
72287   Dali::Toolkit::ImageView result;
72288
72289   argp1 = (Dali::Image *)jarg1;
72290   if (!argp1) {
72291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72292     return 0;
72293   }
72294   arg1 = *argp1;
72295   {
72296     try {
72297       result = Dali::Toolkit::ImageView::New(arg1);
72298     } catch (std::out_of_range& e) {
72299       {
72300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72301       };
72302     } catch (std::exception& e) {
72303       {
72304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72305       };
72306     } catch (Dali::DaliException e) {
72307       {
72308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72309       };
72310     } catch (...) {
72311       {
72312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72313       };
72314     }
72315   }
72316
72317   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72318   return jresult;
72319 }
72320
72321
72322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
72323   void * jresult ;
72324   std::string *arg1 = 0 ;
72325   Dali::Toolkit::ImageView result;
72326
72327   if (!jarg1) {
72328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72329     return 0;
72330   }
72331   std::string arg1_str(jarg1);
72332   arg1 = &arg1_str;
72333   {
72334     try {
72335       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
72336     } catch (std::out_of_range& e) {
72337       {
72338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72339       };
72340     } catch (std::exception& e) {
72341       {
72342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72343       };
72344     } catch (Dali::DaliException e) {
72345       {
72346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72347       };
72348     } catch (...) {
72349       {
72350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72351       };
72352     }
72353   }
72354
72355   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72356
72357   //argout typemap for const std::string&
72358
72359   return jresult;
72360 }
72361
72362
72363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
72364   void * jresult ;
72365   std::string *arg1 = 0 ;
72366   Dali::ImageDimensions arg2 ;
72367   Dali::ImageDimensions *argp2 ;
72368   Dali::Toolkit::ImageView result;
72369
72370   if (!jarg1) {
72371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72372     return 0;
72373   }
72374   std::string arg1_str(jarg1);
72375   arg1 = &arg1_str;
72376   argp2 = (Dali::ImageDimensions *)jarg2;
72377   if (!argp2) {
72378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72379     return 0;
72380   }
72381   arg2 = *argp2;
72382   {
72383     try {
72384       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
72385     } catch (std::out_of_range& e) {
72386       {
72387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72388       };
72389     } catch (std::exception& e) {
72390       {
72391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72392       };
72393     } catch (Dali::DaliException e) {
72394       {
72395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72396       };
72397     } catch (...) {
72398       {
72399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72400       };
72401     }
72402   }
72403
72404   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72405
72406   //argout typemap for const std::string&
72407
72408   return jresult;
72409 }
72410
72411
72412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
72413   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72414
72415   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72416   {
72417     try {
72418       delete arg1;
72419     } catch (std::out_of_range& e) {
72420       {
72421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72422       };
72423     } catch (std::exception& e) {
72424       {
72425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72426       };
72427     } catch (Dali::DaliException e) {
72428       {
72429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72430       };
72431     } catch (...) {
72432       {
72433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72434       };
72435     }
72436   }
72437
72438 }
72439
72440
72441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
72442   void * jresult ;
72443   Dali::Toolkit::ImageView *arg1 = 0 ;
72444   Dali::Toolkit::ImageView *result = 0 ;
72445
72446   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72447   if (!arg1) {
72448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72449     return 0;
72450   }
72451   {
72452     try {
72453       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
72454     } catch (std::out_of_range& e) {
72455       {
72456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72457       };
72458     } catch (std::exception& e) {
72459       {
72460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72461       };
72462     } catch (Dali::DaliException e) {
72463       {
72464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72465       };
72466     } catch (...) {
72467       {
72468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72469       };
72470     }
72471   }
72472
72473   jresult = (void *)result;
72474   return jresult;
72475 }
72476
72477
72478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
72479   void * jresult ;
72480   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72481   Dali::Toolkit::ImageView *arg2 = 0 ;
72482   Dali::Toolkit::ImageView *result = 0 ;
72483
72484   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72485   arg2 = (Dali::Toolkit::ImageView *)jarg2;
72486   if (!arg2) {
72487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72488     return 0;
72489   }
72490   {
72491     try {
72492       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
72493     } catch (std::out_of_range& e) {
72494       {
72495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72496       };
72497     } catch (std::exception& e) {
72498       {
72499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72500       };
72501     } catch (Dali::DaliException e) {
72502       {
72503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72504       };
72505     } catch (...) {
72506       {
72507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72508       };
72509     }
72510   }
72511
72512   jresult = (void *)result;
72513   return jresult;
72514 }
72515
72516
72517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72518   void * jresult ;
72519   Dali::BaseHandle arg1 ;
72520   Dali::BaseHandle *argp1 ;
72521   Dali::Toolkit::ImageView result;
72522
72523   argp1 = (Dali::BaseHandle *)jarg1;
72524   if (!argp1) {
72525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72526     return 0;
72527   }
72528   arg1 = *argp1;
72529   {
72530     try {
72531       result = Dali::Toolkit::ImageView::DownCast(arg1);
72532     } catch (std::out_of_range& e) {
72533       {
72534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72535       };
72536     } catch (std::exception& e) {
72537       {
72538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72539       };
72540     } catch (Dali::DaliException e) {
72541       {
72542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72543       };
72544     } catch (...) {
72545       {
72546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72547       };
72548     }
72549   }
72550
72551   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72552   return jresult;
72553 }
72554
72555
72556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72557   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72558   Dali::Image arg2 ;
72559   Dali::Image *argp2 ;
72560
72561   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72562   argp2 = (Dali::Image *)jarg2;
72563   if (!argp2) {
72564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72565     return ;
72566   }
72567   arg2 = *argp2;
72568   {
72569     try {
72570       (arg1)->SetImage(arg2);
72571     } catch (std::out_of_range& e) {
72572       {
72573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72574       };
72575     } catch (std::exception& e) {
72576       {
72577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72578       };
72579     } catch (Dali::DaliException e) {
72580       {
72581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72582       };
72583     } catch (...) {
72584       {
72585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72586       };
72587     }
72588   }
72589
72590 }
72591
72592
72593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72594   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72595   std::string *arg2 = 0 ;
72596
72597   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72598   if (!jarg2) {
72599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72600     return ;
72601   }
72602   std::string arg2_str(jarg2);
72603   arg2 = &arg2_str;
72604   {
72605     try {
72606       (arg1)->SetImage((std::string const &)*arg2);
72607     } catch (std::out_of_range& e) {
72608       {
72609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72610       };
72611     } catch (std::exception& e) {
72612       {
72613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72614       };
72615     } catch (Dali::DaliException e) {
72616       {
72617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72618       };
72619     } catch (...) {
72620       {
72621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72622       };
72623     }
72624   }
72625
72626
72627   //argout typemap for const std::string&
72628
72629 }
72630
72631
72632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72633   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72634   std::string *arg2 = 0 ;
72635   Dali::ImageDimensions arg3 ;
72636   Dali::ImageDimensions *argp3 ;
72637
72638   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72639   if (!jarg2) {
72640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72641     return ;
72642   }
72643   std::string arg2_str(jarg2);
72644   arg2 = &arg2_str;
72645   argp3 = (Dali::ImageDimensions *)jarg3;
72646   if (!argp3) {
72647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72648     return ;
72649   }
72650   arg3 = *argp3;
72651   {
72652     try {
72653       (arg1)->SetImage((std::string const &)*arg2,arg3);
72654     } catch (std::out_of_range& e) {
72655       {
72656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72657       };
72658     } catch (std::exception& e) {
72659       {
72660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72661       };
72662     } catch (Dali::DaliException e) {
72663       {
72664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72665       };
72666     } catch (...) {
72667       {
72668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72669       };
72670     }
72671   }
72672
72673
72674   //argout typemap for const std::string&
72675
72676 }
72677
72678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72679   void * jresult ;
72680   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72681   Dali::Image result;
72682
72683   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72684   {
72685     try {
72686       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72687     } catch (std::out_of_range& e) {
72688       {
72689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72690       };
72691     } catch (std::exception& e) {
72692       {
72693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72694       };
72695     } catch (Dali::DaliException e) {
72696       {
72697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72698       };
72699     } catch (...) {
72700       {
72701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72702       };
72703     }
72704   }
72705
72706   jresult = new Dali::Image((const Dali::Image &)result);
72707   return jresult;
72708 }
72709
72710
72711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72712   int jresult ;
72713   int result;
72714
72715   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72716   jresult = (int)result;
72717   return jresult;
72718 }
72719
72720
72721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72722   int jresult ;
72723   int result;
72724
72725   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72726   jresult = (int)result;
72727   return jresult;
72728 }
72729
72730
72731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72732   int jresult ;
72733   int result;
72734
72735   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72736   jresult = (int)result;
72737   return jresult;
72738 }
72739
72740
72741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72742   int jresult ;
72743   int result;
72744
72745   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72746   jresult = (int)result;
72747   return jresult;
72748 }
72749
72750
72751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72752   int jresult ;
72753   int result;
72754
72755   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72756   jresult = (int)result;
72757   return jresult;
72758 }
72759
72760
72761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72762   int jresult ;
72763   int result;
72764
72765   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72766   jresult = (int)result;
72767   return jresult;
72768 }
72769
72770
72771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72772   int jresult ;
72773   int result;
72774
72775   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72776   jresult = (int)result;
72777   return jresult;
72778 }
72779
72780
72781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72782   int jresult ;
72783   int result;
72784
72785   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72786   jresult = (int)result;
72787   return jresult;
72788 }
72789
72790
72791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72792   void * jresult ;
72793   Dali::Toolkit::Model3dView::Property *result = 0 ;
72794
72795   {
72796     try {
72797       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72798     } catch (std::out_of_range& e) {
72799       {
72800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72801       };
72802     } catch (std::exception& e) {
72803       {
72804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72805       };
72806     } catch (Dali::DaliException e) {
72807       {
72808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72809       };
72810     } catch (...) {
72811       {
72812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72813       };
72814     }
72815   }
72816
72817   jresult = (void *)result;
72818   return jresult;
72819 }
72820
72821
72822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72823   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72824
72825   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72826   {
72827     try {
72828       delete arg1;
72829     } catch (std::out_of_range& e) {
72830       {
72831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72832       };
72833     } catch (std::exception& e) {
72834       {
72835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72836       };
72837     } catch (Dali::DaliException e) {
72838       {
72839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72840       };
72841     } catch (...) {
72842       {
72843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72844       };
72845     }
72846   }
72847
72848 }
72849
72850
72851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72852   void * jresult ;
72853   Dali::Toolkit::Model3dView result;
72854
72855   {
72856     try {
72857       result = Dali::Toolkit::Model3dView::New();
72858     } catch (std::out_of_range& e) {
72859       {
72860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72861       };
72862     } catch (std::exception& e) {
72863       {
72864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72865       };
72866     } catch (Dali::DaliException e) {
72867       {
72868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72869       };
72870     } catch (...) {
72871       {
72872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72873       };
72874     }
72875   }
72876
72877   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72878   return jresult;
72879 }
72880
72881
72882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72883   void * jresult ;
72884   std::string *arg1 = 0 ;
72885   std::string *arg2 = 0 ;
72886   std::string *arg3 = 0 ;
72887   Dali::Toolkit::Model3dView result;
72888
72889   if (!jarg1) {
72890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72891     return 0;
72892   }
72893   std::string arg1_str(jarg1);
72894   arg1 = &arg1_str;
72895   if (!jarg2) {
72896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72897     return 0;
72898   }
72899   std::string arg2_str(jarg2);
72900   arg2 = &arg2_str;
72901   if (!jarg3) {
72902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72903     return 0;
72904   }
72905   std::string arg3_str(jarg3);
72906   arg3 = &arg3_str;
72907   {
72908     try {
72909       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72910     } catch (std::out_of_range& e) {
72911       {
72912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72913       };
72914     } catch (std::exception& e) {
72915       {
72916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72917       };
72918     } catch (Dali::DaliException e) {
72919       {
72920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72921       };
72922     } catch (...) {
72923       {
72924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72925       };
72926     }
72927   }
72928
72929   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72930
72931   //argout typemap for const std::string&
72932
72933
72934   //argout typemap for const std::string&
72935
72936
72937   //argout typemap for const std::string&
72938
72939   return jresult;
72940 }
72941
72942
72943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72944   void * jresult ;
72945   Dali::Toolkit::Model3dView *result = 0 ;
72946
72947   {
72948     try {
72949       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72950     } catch (std::out_of_range& e) {
72951       {
72952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72953       };
72954     } catch (std::exception& e) {
72955       {
72956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72957       };
72958     } catch (Dali::DaliException e) {
72959       {
72960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72961       };
72962     } catch (...) {
72963       {
72964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72965       };
72966     }
72967   }
72968
72969   jresult = (void *)result;
72970   return jresult;
72971 }
72972
72973
72974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72975   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72976
72977   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72978   {
72979     try {
72980       delete arg1;
72981     } catch (std::out_of_range& e) {
72982       {
72983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72984       };
72985     } catch (std::exception& e) {
72986       {
72987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72988       };
72989     } catch (Dali::DaliException e) {
72990       {
72991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72992       };
72993     } catch (...) {
72994       {
72995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72996       };
72997     }
72998   }
72999
73000 }
73001
73002
73003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
73004   void * jresult ;
73005   Dali::Toolkit::Model3dView *arg1 = 0 ;
73006   Dali::Toolkit::Model3dView *result = 0 ;
73007
73008   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
73009   if (!arg1) {
73010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
73011     return 0;
73012   }
73013   {
73014     try {
73015       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
73016     } catch (std::out_of_range& e) {
73017       {
73018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73019       };
73020     } catch (std::exception& e) {
73021       {
73022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73023       };
73024     } catch (Dali::DaliException e) {
73025       {
73026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73027       };
73028     } catch (...) {
73029       {
73030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73031       };
73032     }
73033   }
73034
73035   jresult = (void *)result;
73036   return jresult;
73037 }
73038
73039
73040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
73041   void * jresult ;
73042   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
73043   Dali::Toolkit::Model3dView *arg2 = 0 ;
73044   Dali::Toolkit::Model3dView *result = 0 ;
73045
73046   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
73047   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
73048   if (!arg2) {
73049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
73050     return 0;
73051   }
73052   {
73053     try {
73054       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
73055     } catch (std::out_of_range& e) {
73056       {
73057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73058       };
73059     } catch (std::exception& e) {
73060       {
73061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73062       };
73063     } catch (Dali::DaliException e) {
73064       {
73065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73066       };
73067     } catch (...) {
73068       {
73069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73070       };
73071     }
73072   }
73073
73074   jresult = (void *)result;
73075   return jresult;
73076 }
73077
73078
73079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
73080   void * jresult ;
73081   Dali::BaseHandle arg1 ;
73082   Dali::BaseHandle *argp1 ;
73083   Dali::Toolkit::Model3dView result;
73084
73085   argp1 = (Dali::BaseHandle *)jarg1;
73086   if (!argp1) {
73087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73088     return 0;
73089   }
73090   arg1 = *argp1;
73091   {
73092     try {
73093       result = Dali::Toolkit::Model3dView::DownCast(arg1);
73094     } catch (std::out_of_range& e) {
73095       {
73096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73097       };
73098     } catch (std::exception& e) {
73099       {
73100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73101       };
73102     } catch (Dali::DaliException e) {
73103       {
73104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73105       };
73106     } catch (...) {
73107       {
73108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73109       };
73110     }
73111   }
73112
73113   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
73114   return jresult;
73115 }
73116
73117
73118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
73119   int jresult ;
73120   int result;
73121
73122   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
73123   jresult = (int)result;
73124   return jresult;
73125 }
73126
73127
73128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
73129   int jresult ;
73130   int result;
73131
73132   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
73133   jresult = (int)result;
73134   return jresult;
73135 }
73136
73137
73138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
73139   int jresult ;
73140   int result;
73141
73142   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
73143   jresult = (int)result;
73144   return jresult;
73145 }
73146
73147
73148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
73149   int jresult ;
73150   int result;
73151
73152   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
73153   jresult = (int)result;
73154   return jresult;
73155 }
73156
73157
73158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
73159   int jresult ;
73160   int result;
73161
73162   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
73163   jresult = (int)result;
73164   return jresult;
73165 }
73166
73167
73168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
73169   int jresult ;
73170   int result;
73171
73172   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
73173   jresult = (int)result;
73174   return jresult;
73175 }
73176
73177
73178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
73179   int jresult ;
73180   int result;
73181
73182   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
73183   jresult = (int)result;
73184   return jresult;
73185 }
73186
73187
73188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
73189   int jresult ;
73190   int result;
73191
73192   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
73193   jresult = (int)result;
73194   return jresult;
73195 }
73196
73197
73198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
73199   int jresult ;
73200   int result;
73201
73202   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
73203   jresult = (int)result;
73204   return jresult;
73205 }
73206
73207
73208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
73209   void * jresult ;
73210   Dali::Toolkit::ScrollBar::Property *result = 0 ;
73211
73212   {
73213     try {
73214       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
73215     } catch (std::out_of_range& e) {
73216       {
73217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73218       };
73219     } catch (std::exception& e) {
73220       {
73221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73222       };
73223     } catch (Dali::DaliException e) {
73224       {
73225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73226       };
73227     } catch (...) {
73228       {
73229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73230       };
73231     }
73232   }
73233
73234   jresult = (void *)result;
73235   return jresult;
73236 }
73237
73238
73239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
73240   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
73241
73242   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
73243   {
73244     try {
73245       delete arg1;
73246     } catch (std::out_of_range& e) {
73247       {
73248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73249       };
73250     } catch (std::exception& e) {
73251       {
73252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73253       };
73254     } catch (Dali::DaliException e) {
73255       {
73256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73257       };
73258     } catch (...) {
73259       {
73260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73261       };
73262     }
73263   }
73264
73265 }
73266
73267
73268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
73269   void * jresult ;
73270   Dali::Toolkit::ScrollBar *result = 0 ;
73271
73272   {
73273     try {
73274       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
73275     } catch (std::out_of_range& e) {
73276       {
73277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73278       };
73279     } catch (std::exception& e) {
73280       {
73281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73282       };
73283     } catch (Dali::DaliException e) {
73284       {
73285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73286       };
73287     } catch (...) {
73288       {
73289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73290       };
73291     }
73292   }
73293
73294   jresult = (void *)result;
73295   return jresult;
73296 }
73297
73298
73299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
73300   void * jresult ;
73301   Dali::Toolkit::ScrollBar *arg1 = 0 ;
73302   Dali::Toolkit::ScrollBar *result = 0 ;
73303
73304   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73305   if (!arg1) {
73306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73307     return 0;
73308   }
73309   {
73310     try {
73311       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
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_ScrollBar_Assign(void * jarg1, void * jarg2) {
73337   void * jresult ;
73338   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73339   Dali::Toolkit::ScrollBar *arg2 = 0 ;
73340   Dali::Toolkit::ScrollBar *result = 0 ;
73341
73342   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73343   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
73344   if (!arg2) {
73345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73346     return 0;
73347   }
73348   {
73349     try {
73350       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
73351     } catch (std::out_of_range& e) {
73352       {
73353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73354       };
73355     } catch (std::exception& e) {
73356       {
73357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73358       };
73359     } catch (Dali::DaliException e) {
73360       {
73361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73362       };
73363     } catch (...) {
73364       {
73365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73366       };
73367     }
73368   }
73369
73370   jresult = (void *)result;
73371   return jresult;
73372 }
73373
73374
73375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
73376   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73377
73378   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73379   {
73380     try {
73381       delete arg1;
73382     } catch (std::out_of_range& e) {
73383       {
73384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73385       };
73386     } catch (std::exception& e) {
73387       {
73388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73389       };
73390     } catch (Dali::DaliException e) {
73391       {
73392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73393       };
73394     } catch (...) {
73395       {
73396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73397       };
73398     }
73399   }
73400
73401 }
73402
73403
73404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
73405   void * jresult ;
73406   Dali::Toolkit::ScrollBar::Direction arg1 ;
73407   Dali::Toolkit::ScrollBar result;
73408
73409   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
73410   {
73411     try {
73412       result = Dali::Toolkit::ScrollBar::New(arg1);
73413     } catch (std::out_of_range& e) {
73414       {
73415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73416       };
73417     } catch (std::exception& e) {
73418       {
73419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73420       };
73421     } catch (Dali::DaliException e) {
73422       {
73423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73424       };
73425     } catch (...) {
73426       {
73427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73428       };
73429     }
73430   }
73431
73432   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73433   return jresult;
73434 }
73435
73436
73437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
73438   void * jresult ;
73439   Dali::Toolkit::ScrollBar result;
73440
73441   {
73442     try {
73443       result = Dali::Toolkit::ScrollBar::New();
73444     } catch (std::out_of_range& e) {
73445       {
73446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73447       };
73448     } catch (std::exception& e) {
73449       {
73450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73451       };
73452     } catch (Dali::DaliException e) {
73453       {
73454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73455       };
73456     } catch (...) {
73457       {
73458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73459       };
73460     }
73461   }
73462
73463   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73464   return jresult;
73465 }
73466
73467
73468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
73469   void * jresult ;
73470   Dali::BaseHandle arg1 ;
73471   Dali::BaseHandle *argp1 ;
73472   Dali::Toolkit::ScrollBar result;
73473
73474   argp1 = (Dali::BaseHandle *)jarg1;
73475   if (!argp1) {
73476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73477     return 0;
73478   }
73479   arg1 = *argp1;
73480   {
73481     try {
73482       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
73483     } catch (std::out_of_range& e) {
73484       {
73485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73486       };
73487     } catch (std::exception& e) {
73488       {
73489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73490       };
73491     } catch (Dali::DaliException e) {
73492       {
73493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73494       };
73495     } catch (...) {
73496       {
73497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73498       };
73499     }
73500   }
73501
73502   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73503   return jresult;
73504 }
73505
73506
73507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73508   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73509   Dali::Handle arg2 ;
73510   Dali::Property::Index arg3 ;
73511   Dali::Property::Index arg4 ;
73512   Dali::Property::Index arg5 ;
73513   Dali::Property::Index arg6 ;
73514   Dali::Handle *argp2 ;
73515
73516   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73517   argp2 = (Dali::Handle *)jarg2;
73518   if (!argp2) {
73519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73520     return ;
73521   }
73522   arg2 = *argp2;
73523   arg3 = (Dali::Property::Index)jarg3;
73524   arg4 = (Dali::Property::Index)jarg4;
73525   arg5 = (Dali::Property::Index)jarg5;
73526   arg6 = (Dali::Property::Index)jarg6;
73527   {
73528     try {
73529       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73530     } catch (std::out_of_range& e) {
73531       {
73532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73533       };
73534     } catch (std::exception& e) {
73535       {
73536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73537       };
73538     } catch (Dali::DaliException e) {
73539       {
73540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73541       };
73542     } catch (...) {
73543       {
73544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73545       };
73546     }
73547   }
73548
73549 }
73550
73551
73552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73553   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73554   Dali::Actor arg2 ;
73555   Dali::Actor *argp2 ;
73556
73557   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73558   argp2 = (Dali::Actor *)jarg2;
73559   if (!argp2) {
73560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73561     return ;
73562   }
73563   arg2 = *argp2;
73564   {
73565     try {
73566       (arg1)->SetScrollIndicator(arg2);
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_GetScrollIndicator(void * jarg1) {
73590   void * jresult ;
73591   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73592   Dali::Actor result;
73593
73594   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73595   {
73596     try {
73597       result = (arg1)->GetScrollIndicator();
73598     } catch (std::out_of_range& e) {
73599       {
73600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73601       };
73602     } catch (std::exception& e) {
73603       {
73604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73605       };
73606     } catch (Dali::DaliException e) {
73607       {
73608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73609       };
73610     } catch (...) {
73611       {
73612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73613       };
73614     }
73615   }
73616
73617   jresult = new Dali::Actor((const Dali::Actor &)result);
73618   return jresult;
73619 }
73620
73621
73622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73623   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73624   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73625
73626   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73627   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73628   if (!arg2) {
73629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73630     return ;
73631   }
73632   {
73633     try {
73634       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73635     } catch (std::out_of_range& e) {
73636       {
73637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73638       };
73639     } catch (std::exception& e) {
73640       {
73641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73642       };
73643     } catch (Dali::DaliException e) {
73644       {
73645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73646       };
73647     } catch (...) {
73648       {
73649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73650       };
73651     }
73652   }
73653
73654 }
73655
73656
73657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73658   void * jresult ;
73659   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73660
73661   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73662   {
73663     try {
73664       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()));
73665     } catch (std::out_of_range& e) {
73666       {
73667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73668       };
73669     } catch (std::exception& e) {
73670       {
73671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73672       };
73673     } catch (...) {
73674       {
73675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73676       };
73677     }
73678   }
73679   return jresult;
73680 }
73681
73682
73683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73684   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73685   Dali::Toolkit::ScrollBar::Direction arg2 ;
73686
73687   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73688   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73689   {
73690     try {
73691       (arg1)->SetScrollDirection(arg2);
73692     } catch (std::out_of_range& e) {
73693       {
73694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73695       };
73696     } catch (std::exception& e) {
73697       {
73698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73699       };
73700     } catch (Dali::DaliException e) {
73701       {
73702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73703       };
73704     } catch (...) {
73705       {
73706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73707       };
73708     }
73709   }
73710
73711 }
73712
73713
73714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73715   int jresult ;
73716   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73717   Dali::Toolkit::ScrollBar::Direction result;
73718
73719   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73720   {
73721     try {
73722       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73723     } catch (std::out_of_range& e) {
73724       {
73725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73726       };
73727     } catch (std::exception& e) {
73728       {
73729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73730       };
73731     } catch (Dali::DaliException e) {
73732       {
73733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73734       };
73735     } catch (...) {
73736       {
73737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73738       };
73739     }
73740   }
73741
73742   jresult = (int)result;
73743   return jresult;
73744 }
73745
73746
73747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73748   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73749   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73750
73751   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73752   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73753   {
73754     try {
73755       (arg1)->SetIndicatorHeightPolicy(arg2);
73756     } catch (std::out_of_range& e) {
73757       {
73758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73759       };
73760     } catch (std::exception& e) {
73761       {
73762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73763       };
73764     } catch (Dali::DaliException e) {
73765       {
73766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73767       };
73768     } catch (...) {
73769       {
73770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73771       };
73772     }
73773   }
73774
73775 }
73776
73777
73778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73779   int jresult ;
73780   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73781   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73782
73783   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73784   {
73785     try {
73786       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73787     } catch (std::out_of_range& e) {
73788       {
73789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73790       };
73791     } catch (std::exception& e) {
73792       {
73793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73794       };
73795     } catch (Dali::DaliException e) {
73796       {
73797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73798       };
73799     } catch (...) {
73800       {
73801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73802       };
73803     }
73804   }
73805
73806   jresult = (int)result;
73807   return jresult;
73808 }
73809
73810
73811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73812   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73813   float arg2 ;
73814
73815   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73816   arg2 = (float)jarg2;
73817   {
73818     try {
73819       (arg1)->SetIndicatorFixedHeight(arg2);
73820     } catch (std::out_of_range& e) {
73821       {
73822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73823       };
73824     } catch (std::exception& e) {
73825       {
73826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73827       };
73828     } catch (Dali::DaliException e) {
73829       {
73830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73831       };
73832     } catch (...) {
73833       {
73834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73835       };
73836     }
73837   }
73838
73839 }
73840
73841
73842 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73843   float jresult ;
73844   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73845   float result;
73846
73847   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73848   {
73849     try {
73850       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73851     } catch (std::out_of_range& e) {
73852       {
73853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73854       };
73855     } catch (std::exception& e) {
73856       {
73857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73858       };
73859     } catch (Dali::DaliException e) {
73860       {
73861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73862       };
73863     } catch (...) {
73864       {
73865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73866       };
73867     }
73868   }
73869
73870   jresult = result;
73871   return jresult;
73872 }
73873
73874
73875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73876   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73877   float arg2 ;
73878
73879   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73880   arg2 = (float)jarg2;
73881   {
73882     try {
73883       (arg1)->SetIndicatorShowDuration(arg2);
73884     } catch (std::out_of_range& e) {
73885       {
73886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73887       };
73888     } catch (std::exception& e) {
73889       {
73890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73891       };
73892     } catch (Dali::DaliException e) {
73893       {
73894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73895       };
73896     } catch (...) {
73897       {
73898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73899       };
73900     }
73901   }
73902
73903 }
73904
73905
73906 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73907   float jresult ;
73908   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73909   float result;
73910
73911   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73912   {
73913     try {
73914       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73915     } catch (std::out_of_range& e) {
73916       {
73917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73918       };
73919     } catch (std::exception& e) {
73920       {
73921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73922       };
73923     } catch (Dali::DaliException e) {
73924       {
73925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73926       };
73927     } catch (...) {
73928       {
73929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73930       };
73931     }
73932   }
73933
73934   jresult = result;
73935   return jresult;
73936 }
73937
73938
73939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73940   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73941   float arg2 ;
73942
73943   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73944   arg2 = (float)jarg2;
73945   {
73946     try {
73947       (arg1)->SetIndicatorHideDuration(arg2);
73948     } catch (std::out_of_range& e) {
73949       {
73950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73951       };
73952     } catch (std::exception& e) {
73953       {
73954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73955       };
73956     } catch (Dali::DaliException e) {
73957       {
73958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73959       };
73960     } catch (...) {
73961       {
73962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73963       };
73964     }
73965   }
73966
73967 }
73968
73969
73970 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73971   float jresult ;
73972   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73973   float result;
73974
73975   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73976   {
73977     try {
73978       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73979     } catch (std::out_of_range& e) {
73980       {
73981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73982       };
73983     } catch (std::exception& e) {
73984       {
73985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73986       };
73987     } catch (Dali::DaliException e) {
73988       {
73989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73990       };
73991     } catch (...) {
73992       {
73993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73994       };
73995     }
73996   }
73997
73998   jresult = result;
73999   return jresult;
74000 }
74001
74002
74003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
74004   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74005
74006   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74007   {
74008     try {
74009       (arg1)->ShowIndicator();
74010     } catch (std::out_of_range& e) {
74011       {
74012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74013       };
74014     } catch (std::exception& e) {
74015       {
74016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74017       };
74018     } catch (Dali::DaliException e) {
74019       {
74020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74021       };
74022     } catch (...) {
74023       {
74024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74025       };
74026     }
74027   }
74028
74029 }
74030
74031
74032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
74033   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74034
74035   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74036   {
74037     try {
74038       (arg1)->HideIndicator();
74039     } catch (std::out_of_range& e) {
74040       {
74041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74042       };
74043     } catch (std::exception& e) {
74044       {
74045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74046       };
74047     } catch (Dali::DaliException e) {
74048       {
74049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74050       };
74051     } catch (...) {
74052       {
74053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74054       };
74055     }
74056   }
74057
74058 }
74059
74060
74061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
74062   void * jresult ;
74063   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74064   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
74065
74066   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74067   {
74068     try {
74069       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
74070     } catch (std::out_of_range& e) {
74071       {
74072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74073       };
74074     } catch (std::exception& e) {
74075       {
74076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74077       };
74078     } catch (Dali::DaliException e) {
74079       {
74080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74081       };
74082     } catch (...) {
74083       {
74084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74085       };
74086     }
74087   }
74088
74089   jresult = (void *)result;
74090   return jresult;
74091 }
74092
74093
74094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
74095   void * jresult ;
74096   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74097   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
74098
74099   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74100   {
74101     try {
74102       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
74103     } catch (std::out_of_range& e) {
74104       {
74105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74106       };
74107     } catch (std::exception& e) {
74108       {
74109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74110       };
74111     } catch (Dali::DaliException e) {
74112       {
74113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74114       };
74115     } catch (...) {
74116       {
74117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74118       };
74119     }
74120   }
74121
74122   jresult = (void *)result;
74123   return jresult;
74124 }
74125
74126
74127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
74128   int jresult ;
74129   int result;
74130
74131   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
74132   jresult = (int)result;
74133   return jresult;
74134 }
74135
74136
74137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
74138   int jresult ;
74139   int result;
74140
74141   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
74142   jresult = (int)result;
74143   return jresult;
74144 }
74145
74146
74147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
74148   int jresult ;
74149   int result;
74150
74151   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
74152   jresult = (int)result;
74153   return jresult;
74154 }
74155
74156
74157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
74158   int jresult ;
74159   int result;
74160
74161   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
74162   jresult = (int)result;
74163   return jresult;
74164 }
74165
74166
74167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
74168   int jresult ;
74169   int result;
74170
74171   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
74172   jresult = (int)result;
74173   return jresult;
74174 }
74175
74176
74177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
74178   int jresult ;
74179   int result;
74180
74181   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
74182   jresult = (int)result;
74183   return jresult;
74184 }
74185
74186
74187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
74188   int jresult ;
74189   int result;
74190
74191   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
74192   jresult = (int)result;
74193   return jresult;
74194 }
74195
74196
74197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
74198   int jresult ;
74199   int result;
74200
74201   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
74202   jresult = (int)result;
74203   return jresult;
74204 }
74205
74206
74207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
74208   int jresult ;
74209   int result;
74210
74211   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
74212   jresult = (int)result;
74213   return jresult;
74214 }
74215
74216
74217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
74218   int jresult ;
74219   int result;
74220
74221   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
74222   jresult = (int)result;
74223   return jresult;
74224 }
74225
74226
74227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
74228   int jresult ;
74229   int result;
74230
74231   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
74232   jresult = (int)result;
74233   return jresult;
74234 }
74235
74236
74237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
74238   int jresult ;
74239   int result;
74240
74241   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
74242   jresult = (int)result;
74243   return jresult;
74244 }
74245
74246
74247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
74248   int jresult ;
74249   int result;
74250
74251   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
74252   jresult = (int)result;
74253   return jresult;
74254 }
74255
74256
74257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
74258   int jresult ;
74259   int result;
74260
74261   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
74262   jresult = (int)result;
74263   return jresult;
74264 }
74265
74266
74267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
74268   void * jresult ;
74269   Dali::Toolkit::Scrollable::Property *result = 0 ;
74270
74271   {
74272     try {
74273       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
74274     } catch (std::out_of_range& e) {
74275       {
74276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74277       };
74278     } catch (std::exception& e) {
74279       {
74280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74281       };
74282     } catch (Dali::DaliException e) {
74283       {
74284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74285       };
74286     } catch (...) {
74287       {
74288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74289       };
74290     }
74291   }
74292
74293   jresult = (void *)result;
74294   return jresult;
74295 }
74296
74297
74298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
74299   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
74300
74301   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
74302   {
74303     try {
74304       delete arg1;
74305     } catch (std::out_of_range& e) {
74306       {
74307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74308       };
74309     } catch (std::exception& e) {
74310       {
74311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74312       };
74313     } catch (Dali::DaliException e) {
74314       {
74315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74316       };
74317     } catch (...) {
74318       {
74319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74320       };
74321     }
74322   }
74323
74324 }
74325
74326
74327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
74328   void * jresult ;
74329   Dali::Toolkit::Scrollable *result = 0 ;
74330
74331   {
74332     try {
74333       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
74334     } catch (std::out_of_range& e) {
74335       {
74336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74337       };
74338     } catch (std::exception& e) {
74339       {
74340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74341       };
74342     } catch (Dali::DaliException e) {
74343       {
74344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74345       };
74346     } catch (...) {
74347       {
74348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74349       };
74350     }
74351   }
74352
74353   jresult = (void *)result;
74354   return jresult;
74355 }
74356
74357
74358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
74359   void * jresult ;
74360   Dali::Toolkit::Scrollable *arg1 = 0 ;
74361   Dali::Toolkit::Scrollable *result = 0 ;
74362
74363   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74364   if (!arg1) {
74365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74366     return 0;
74367   }
74368   {
74369     try {
74370       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
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_Scrollable_Assign(void * jarg1, void * jarg2) {
74396   void * jresult ;
74397   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74398   Dali::Toolkit::Scrollable *arg2 = 0 ;
74399   Dali::Toolkit::Scrollable *result = 0 ;
74400
74401   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74402   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
74403   if (!arg2) {
74404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74405     return 0;
74406   }
74407   {
74408     try {
74409       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
74410     } catch (std::out_of_range& e) {
74411       {
74412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74413       };
74414     } catch (std::exception& e) {
74415       {
74416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74417       };
74418     } catch (Dali::DaliException e) {
74419       {
74420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74421       };
74422     } catch (...) {
74423       {
74424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74425       };
74426     }
74427   }
74428
74429   jresult = (void *)result;
74430   return jresult;
74431 }
74432
74433
74434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
74435   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74436
74437   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74438   {
74439     try {
74440       delete arg1;
74441     } catch (std::out_of_range& e) {
74442       {
74443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74444       };
74445     } catch (std::exception& e) {
74446       {
74447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74448       };
74449     } catch (Dali::DaliException e) {
74450       {
74451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74452       };
74453     } catch (...) {
74454       {
74455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74456       };
74457     }
74458   }
74459
74460 }
74461
74462
74463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
74464   void * jresult ;
74465   Dali::BaseHandle arg1 ;
74466   Dali::BaseHandle *argp1 ;
74467   Dali::Toolkit::Scrollable result;
74468
74469   argp1 = (Dali::BaseHandle *)jarg1;
74470   if (!argp1) {
74471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74472     return 0;
74473   }
74474   arg1 = *argp1;
74475   {
74476     try {
74477       result = Dali::Toolkit::Scrollable::DownCast(arg1);
74478     } catch (std::out_of_range& e) {
74479       {
74480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74481       };
74482     } catch (std::exception& e) {
74483       {
74484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74485       };
74486     } catch (Dali::DaliException e) {
74487       {
74488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74489       };
74490     } catch (...) {
74491       {
74492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74493       };
74494     }
74495   }
74496
74497   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
74498   return jresult;
74499 }
74500
74501
74502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74503   unsigned int jresult ;
74504   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74505   bool result;
74506
74507   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74508   {
74509     try {
74510       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74511     } catch (std::out_of_range& e) {
74512       {
74513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74514       };
74515     } catch (std::exception& e) {
74516       {
74517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74518       };
74519     } catch (Dali::DaliException e) {
74520       {
74521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74522       };
74523     } catch (...) {
74524       {
74525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74526       };
74527     }
74528   }
74529
74530   jresult = result;
74531   return jresult;
74532 }
74533
74534
74535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74536   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74537   bool arg2 ;
74538
74539   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74540   arg2 = jarg2 ? true : false;
74541   {
74542     try {
74543       (arg1)->SetOvershootEnabled(arg2);
74544     } catch (std::out_of_range& e) {
74545       {
74546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74547       };
74548     } catch (std::exception& e) {
74549       {
74550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74551       };
74552     } catch (Dali::DaliException e) {
74553       {
74554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74555       };
74556     } catch (...) {
74557       {
74558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74559       };
74560     }
74561   }
74562
74563 }
74564
74565
74566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74567   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74568   Dali::Vector4 *arg2 = 0 ;
74569
74570   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74571   arg2 = (Dali::Vector4 *)jarg2;
74572   if (!arg2) {
74573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74574     return ;
74575   }
74576   {
74577     try {
74578       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74579     } catch (std::out_of_range& e) {
74580       {
74581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74582       };
74583     } catch (std::exception& e) {
74584       {
74585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74586       };
74587     } catch (Dali::DaliException e) {
74588       {
74589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74590       };
74591     } catch (...) {
74592       {
74593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74594       };
74595     }
74596   }
74597
74598 }
74599
74600
74601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74602   void * jresult ;
74603   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74604   Dali::Vector4 result;
74605
74606   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74607   {
74608     try {
74609       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
74610     } catch (std::out_of_range& e) {
74611       {
74612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74613       };
74614     } catch (std::exception& e) {
74615       {
74616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74617       };
74618     } catch (Dali::DaliException e) {
74619       {
74620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74621       };
74622     } catch (...) {
74623       {
74624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74625       };
74626     }
74627   }
74628
74629   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74630   return jresult;
74631 }
74632
74633
74634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74635   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74636   float arg2 ;
74637
74638   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74639   arg2 = (float)jarg2;
74640   {
74641     try {
74642       (arg1)->SetOvershootAnimationSpeed(arg2);
74643     } catch (std::out_of_range& e) {
74644       {
74645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74646       };
74647     } catch (std::exception& e) {
74648       {
74649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74650       };
74651     } catch (Dali::DaliException e) {
74652       {
74653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74654       };
74655     } catch (...) {
74656       {
74657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74658       };
74659     }
74660   }
74661
74662 }
74663
74664
74665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74666   float jresult ;
74667   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74668   float result;
74669
74670   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74671   {
74672     try {
74673       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74674     } catch (std::out_of_range& e) {
74675       {
74676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74677       };
74678     } catch (std::exception& e) {
74679       {
74680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74681       };
74682     } catch (Dali::DaliException e) {
74683       {
74684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74685       };
74686     } catch (...) {
74687       {
74688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74689       };
74690     }
74691   }
74692
74693   jresult = result;
74694   return jresult;
74695 }
74696
74697
74698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74699   void * jresult ;
74700   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74701   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74702
74703   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74704   {
74705     try {
74706       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74707     } catch (std::out_of_range& e) {
74708       {
74709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74710       };
74711     } catch (std::exception& e) {
74712       {
74713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74714       };
74715     } catch (Dali::DaliException e) {
74716       {
74717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74718       };
74719     } catch (...) {
74720       {
74721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74722       };
74723     }
74724   }
74725
74726   jresult = (void *)result;
74727   return jresult;
74728 }
74729
74730
74731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74732   void * jresult ;
74733   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74734   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74735
74736   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74737   {
74738     try {
74739       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74740     } catch (std::out_of_range& e) {
74741       {
74742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74743       };
74744     } catch (std::exception& e) {
74745       {
74746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74747       };
74748     } catch (Dali::DaliException e) {
74749       {
74750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74751       };
74752     } catch (...) {
74753       {
74754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74755       };
74756     }
74757   }
74758
74759   jresult = (void *)result;
74760   return jresult;
74761 }
74762
74763
74764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74765   void * jresult ;
74766   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74767   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74768
74769   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74770   {
74771     try {
74772       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74773     } catch (std::out_of_range& e) {
74774       {
74775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74776       };
74777     } catch (std::exception& e) {
74778       {
74779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74780       };
74781     } catch (Dali::DaliException e) {
74782       {
74783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74784       };
74785     } catch (...) {
74786       {
74787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74788       };
74789     }
74790   }
74791
74792   jresult = (void *)result;
74793   return jresult;
74794 }
74795
74796
74797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74798   unsigned int jresult ;
74799   Dali::Toolkit::ControlOrientation::Type arg1 ;
74800   bool result;
74801
74802   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74803   {
74804     try {
74805       result = (bool)Dali::Toolkit::IsVertical(arg1);
74806     } catch (std::out_of_range& e) {
74807       {
74808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74809       };
74810     } catch (std::exception& e) {
74811       {
74812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74813       };
74814     } catch (Dali::DaliException e) {
74815       {
74816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74817       };
74818     } catch (...) {
74819       {
74820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74821       };
74822     }
74823   }
74824
74825   jresult = result;
74826   return jresult;
74827 }
74828
74829
74830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74831   unsigned int jresult ;
74832   Dali::Toolkit::ControlOrientation::Type arg1 ;
74833   bool result;
74834
74835   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74836   {
74837     try {
74838       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74839     } catch (std::out_of_range& e) {
74840       {
74841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74842       };
74843     } catch (std::exception& e) {
74844       {
74845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74846       };
74847     } catch (Dali::DaliException e) {
74848       {
74849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74850       };
74851     } catch (...) {
74852       {
74853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74854       };
74855     }
74856   }
74857
74858   jresult = result;
74859   return jresult;
74860 }
74861
74862
74863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74864   void * jresult ;
74865   unsigned int arg1 ;
74866   unsigned int arg2 ;
74867   Dali::Toolkit::ItemRange *result = 0 ;
74868
74869   arg1 = (unsigned int)jarg1;
74870   arg2 = (unsigned int)jarg2;
74871   {
74872     try {
74873       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74874     } catch (std::out_of_range& e) {
74875       {
74876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74877       };
74878     } catch (std::exception& e) {
74879       {
74880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74881       };
74882     } catch (Dali::DaliException e) {
74883       {
74884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74885       };
74886     } catch (...) {
74887       {
74888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74889       };
74890     }
74891   }
74892
74893   jresult = (void *)result;
74894   return jresult;
74895 }
74896
74897
74898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74899   void * jresult ;
74900   Dali::Toolkit::ItemRange *arg1 = 0 ;
74901   Dali::Toolkit::ItemRange *result = 0 ;
74902
74903   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74904   if (!arg1) {
74905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74906     return 0;
74907   }
74908   {
74909     try {
74910       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
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_ItemRange_Assign(void * jarg1, void * jarg2) {
74936   void * jresult ;
74937   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74938   Dali::Toolkit::ItemRange *arg2 = 0 ;
74939   Dali::Toolkit::ItemRange *result = 0 ;
74940
74941   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74942   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74943   if (!arg2) {
74944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74945     return 0;
74946   }
74947   {
74948     try {
74949       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74950     } catch (std::out_of_range& e) {
74951       {
74952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74953       };
74954     } catch (std::exception& e) {
74955       {
74956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74957       };
74958     } catch (Dali::DaliException e) {
74959       {
74960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74961       };
74962     } catch (...) {
74963       {
74964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74965       };
74966     }
74967   }
74968
74969   jresult = (void *)result;
74970   return jresult;
74971 }
74972
74973
74974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74975   unsigned int jresult ;
74976   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74977   unsigned int arg2 ;
74978   bool result;
74979
74980   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74981   arg2 = (unsigned int)jarg2;
74982   {
74983     try {
74984       result = (bool)(arg1)->Within(arg2);
74985     } catch (std::out_of_range& e) {
74986       {
74987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74988       };
74989     } catch (std::exception& e) {
74990       {
74991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74992       };
74993     } catch (Dali::DaliException e) {
74994       {
74995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74996       };
74997     } catch (...) {
74998       {
74999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75000       };
75001     }
75002   }
75003
75004   jresult = result;
75005   return jresult;
75006 }
75007
75008
75009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
75010   void * jresult ;
75011   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75012   Dali::Toolkit::ItemRange *arg2 = 0 ;
75013   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75014
75015   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75016   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
75017   if (!arg2) {
75018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
75019     return 0;
75020   }
75021   {
75022     try {
75023       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
75024     } catch (std::out_of_range& e) {
75025       {
75026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75027       };
75028     } catch (std::exception& e) {
75029       {
75030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75031       };
75032     } catch (Dali::DaliException e) {
75033       {
75034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75035       };
75036     } catch (...) {
75037       {
75038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75039       };
75040     }
75041   }
75042
75043   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75044   return jresult;
75045 }
75046
75047
75048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
75049   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75050   unsigned int arg2 ;
75051
75052   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75053   arg2 = (unsigned int)jarg2;
75054   if (arg1) (arg1)->begin = arg2;
75055 }
75056
75057
75058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
75059   unsigned int jresult ;
75060   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75061   unsigned int result;
75062
75063   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75064   result = (unsigned int) ((arg1)->begin);
75065   jresult = result;
75066   return jresult;
75067 }
75068
75069
75070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
75071   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75072   unsigned int arg2 ;
75073
75074   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75075   arg2 = (unsigned int)jarg2;
75076   if (arg1) (arg1)->end = arg2;
75077 }
75078
75079
75080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
75081   unsigned int jresult ;
75082   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75083   unsigned int result;
75084
75085   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75086   result = (unsigned int) ((arg1)->end);
75087   jresult = result;
75088   return jresult;
75089 }
75090
75091
75092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
75093   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75094
75095   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75096   {
75097     try {
75098       delete arg1;
75099     } catch (std::out_of_range& e) {
75100       {
75101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75102       };
75103     } catch (std::exception& e) {
75104       {
75105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75106       };
75107     } catch (Dali::DaliException e) {
75108       {
75109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75110       };
75111     } catch (...) {
75112       {
75113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75114       };
75115     }
75116   }
75117
75118 }
75119
75120
75121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
75122   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75123
75124   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75125   {
75126     try {
75127       delete arg1;
75128     } catch (std::out_of_range& e) {
75129       {
75130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75131       };
75132     } catch (std::exception& e) {
75133       {
75134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75135       };
75136     } catch (Dali::DaliException e) {
75137       {
75138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75139       };
75140     } catch (...) {
75141       {
75142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75143       };
75144     }
75145   }
75146
75147 }
75148
75149
75150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
75151   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75152   Dali::Toolkit::ControlOrientation::Type arg2 ;
75153
75154   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75155   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
75156   {
75157     try {
75158       (arg1)->SetOrientation(arg2);
75159     } catch (std::out_of_range& e) {
75160       {
75161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75162       };
75163     } catch (std::exception& e) {
75164       {
75165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75166       };
75167     } catch (Dali::DaliException e) {
75168       {
75169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75170       };
75171     } catch (...) {
75172       {
75173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75174       };
75175     }
75176   }
75177
75178 }
75179
75180
75181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
75182   int jresult ;
75183   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75184   Dali::Toolkit::ControlOrientation::Type result;
75185
75186   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75187   {
75188     try {
75189       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
75190     } catch (std::out_of_range& e) {
75191       {
75192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75193       };
75194     } catch (std::exception& e) {
75195       {
75196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75197       };
75198     } catch (Dali::DaliException e) {
75199       {
75200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75201       };
75202     } catch (...) {
75203       {
75204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75205       };
75206     }
75207   }
75208
75209   jresult = (int)result;
75210   return jresult;
75211 }
75212
75213
75214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
75215   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75216   Dali::Property::Map *arg2 = 0 ;
75217
75218   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75219   arg2 = (Dali::Property::Map *)jarg2;
75220   if (!arg2) {
75221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
75222     return ;
75223   }
75224   {
75225     try {
75226       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
75227     } catch (std::out_of_range& e) {
75228       {
75229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75230       };
75231     } catch (std::exception& e) {
75232       {
75233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75234       };
75235     } catch (Dali::DaliException e) {
75236       {
75237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75238       };
75239     } catch (...) {
75240       {
75241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75242       };
75243     }
75244   }
75245
75246 }
75247
75248
75249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
75250   void * jresult ;
75251   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75252   Dali::Property::Map result;
75253
75254   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75255   {
75256     try {
75257       result = (arg1)->GetLayoutProperties();
75258     } catch (std::out_of_range& e) {
75259       {
75260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75261       };
75262     } catch (std::exception& e) {
75263       {
75264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75265       };
75266     } catch (Dali::DaliException e) {
75267       {
75268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75269       };
75270     } catch (...) {
75271       {
75272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75273       };
75274     }
75275   }
75276
75277   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
75278   return jresult;
75279 }
75280
75281
75282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75283   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75284   unsigned int arg2 ;
75285   Dali::Vector3 *arg3 = 0 ;
75286   Dali::Vector3 *arg4 = 0 ;
75287
75288   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75289   arg2 = (unsigned int)jarg2;
75290   arg3 = (Dali::Vector3 *)jarg3;
75291   if (!arg3) {
75292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75293     return ;
75294   }
75295   arg4 = (Dali::Vector3 *)jarg4;
75296   if (!arg4) {
75297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75298     return ;
75299   }
75300   {
75301     try {
75302       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75303     } catch (std::out_of_range& e) {
75304       {
75305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75306       };
75307     } catch (std::exception& e) {
75308       {
75309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75310       };
75311     } catch (Dali::DaliException e) {
75312       {
75313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75314       };
75315     } catch (...) {
75316       {
75317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75318       };
75319     }
75320   }
75321
75322 }
75323
75324
75325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
75326   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75327   Dali::Vector3 *arg2 = 0 ;
75328
75329   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75330   arg2 = (Dali::Vector3 *)jarg2;
75331   if (!arg2) {
75332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75333     return ;
75334   }
75335   {
75336     try {
75337       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
75338     } catch (std::out_of_range& e) {
75339       {
75340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75341       };
75342     } catch (std::exception& e) {
75343       {
75344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75345       };
75346     } catch (Dali::DaliException e) {
75347       {
75348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75349       };
75350     } catch (...) {
75351       {
75352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75353       };
75354     }
75355   }
75356
75357 }
75358
75359
75360 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
75361   float jresult ;
75362   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75363   unsigned int arg2 ;
75364   Dali::Vector3 arg3 ;
75365   Dali::Vector3 *argp3 ;
75366   float result;
75367
75368   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75369   arg2 = (unsigned int)jarg2;
75370   argp3 = (Dali::Vector3 *)jarg3;
75371   if (!argp3) {
75372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75373     return 0;
75374   }
75375   arg3 = *argp3;
75376   {
75377     try {
75378       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
75379     } catch (std::out_of_range& e) {
75380       {
75381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75382       };
75383     } catch (std::exception& e) {
75384       {
75385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75386       };
75387     } catch (Dali::DaliException e) {
75388       {
75389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75390       };
75391     } catch (...) {
75392       {
75393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75394       };
75395     }
75396   }
75397
75398   jresult = result;
75399   return jresult;
75400 }
75401
75402
75403 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
75404   float jresult ;
75405   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75406   float arg2 ;
75407   float result;
75408
75409   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75410   arg2 = (float)jarg2;
75411   {
75412     try {
75413       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
75414     } catch (std::out_of_range& e) {
75415       {
75416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75417       };
75418     } catch (std::exception& e) {
75419       {
75420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75421       };
75422     } catch (Dali::DaliException e) {
75423       {
75424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75425       };
75426     } catch (...) {
75427       {
75428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75429       };
75430     }
75431   }
75432
75433   jresult = result;
75434   return jresult;
75435 }
75436
75437
75438 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
75439   float jresult ;
75440   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75441   unsigned int arg2 ;
75442   float result;
75443
75444   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75445   arg2 = (unsigned int)jarg2;
75446   {
75447     try {
75448       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
75449     } catch (std::out_of_range& e) {
75450       {
75451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75452       };
75453     } catch (std::exception& e) {
75454       {
75455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75456       };
75457     } catch (Dali::DaliException e) {
75458       {
75459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75460       };
75461     } catch (...) {
75462       {
75463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75464       };
75465     }
75466   }
75467
75468   jresult = result;
75469   return jresult;
75470 }
75471
75472
75473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
75474   void * jresult ;
75475   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75476   float arg2 ;
75477   Dali::Vector3 arg3 ;
75478   Dali::Vector3 *argp3 ;
75479   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75480
75481   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75482   arg2 = (float)jarg2;
75483   argp3 = (Dali::Vector3 *)jarg3;
75484   if (!argp3) {
75485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75486     return 0;
75487   }
75488   arg3 = *argp3;
75489   {
75490     try {
75491       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
75492     } catch (std::out_of_range& e) {
75493       {
75494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75495       };
75496     } catch (std::exception& e) {
75497       {
75498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75499       };
75500     } catch (Dali::DaliException e) {
75501       {
75502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75503       };
75504     } catch (...) {
75505       {
75506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75507       };
75508     }
75509   }
75510
75511   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75512   return jresult;
75513 }
75514
75515
75516 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75517   float jresult ;
75518   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75519   int arg2 ;
75520   float arg3 ;
75521   Dali::Vector3 *arg4 = 0 ;
75522   float result;
75523
75524   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75525   arg2 = (int)jarg2;
75526   arg3 = (float)jarg3;
75527   arg4 = (Dali::Vector3 *)jarg4;
75528   if (!arg4) {
75529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75530     return 0;
75531   }
75532   {
75533     try {
75534       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75535     } catch (std::out_of_range& e) {
75536       {
75537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75538       };
75539     } catch (std::exception& e) {
75540       {
75541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75542       };
75543     } catch (Dali::DaliException e) {
75544       {
75545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75546       };
75547     } catch (...) {
75548       {
75549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75550       };
75551     }
75552   }
75553
75554   jresult = result;
75555   return jresult;
75556 }
75557
75558
75559 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75560   unsigned int jresult ;
75561   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75562   Dali::Vector3 arg2 ;
75563   Dali::Vector3 *argp2 ;
75564   unsigned int result;
75565
75566   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75567   argp2 = (Dali::Vector3 *)jarg2;
75568   if (!argp2) {
75569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75570     return 0;
75571   }
75572   arg2 = *argp2;
75573   {
75574     try {
75575       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75576     } catch (std::out_of_range& e) {
75577       {
75578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75579       };
75580     } catch (std::exception& e) {
75581       {
75582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75583       };
75584     } catch (Dali::DaliException e) {
75585       {
75586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75587       };
75588     } catch (...) {
75589       {
75590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75591       };
75592     }
75593   }
75594
75595   jresult = result;
75596   return jresult;
75597 }
75598
75599
75600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75601   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75602   unsigned int arg2 ;
75603   Dali::Vector3 *arg3 = 0 ;
75604   Dali::Vector3 *arg4 = 0 ;
75605
75606   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75607   arg2 = (unsigned int)jarg2;
75608   arg3 = (Dali::Vector3 *)jarg3;
75609   if (!arg3) {
75610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75611     return ;
75612   }
75613   arg4 = (Dali::Vector3 *)jarg4;
75614   if (!arg4) {
75615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75616     return ;
75617   }
75618   {
75619     try {
75620       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75621     } catch (std::out_of_range& e) {
75622       {
75623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75624       };
75625     } catch (std::exception& e) {
75626       {
75627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75628       };
75629     } catch (Dali::DaliException e) {
75630       {
75631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75632       };
75633     } catch (...) {
75634       {
75635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75636       };
75637     }
75638   }
75639
75640 }
75641
75642
75643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75644   void * jresult ;
75645   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75646   Dali::Degree result;
75647
75648   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75649   {
75650     try {
75651       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75652     } catch (std::out_of_range& e) {
75653       {
75654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75655       };
75656     } catch (std::exception& e) {
75657       {
75658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75659       };
75660     } catch (Dali::DaliException e) {
75661       {
75662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75663       };
75664     } catch (...) {
75665       {
75666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75667       };
75668     }
75669   }
75670
75671   jresult = new Dali::Degree((const Dali::Degree &)result);
75672   return jresult;
75673 }
75674
75675
75676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75677   float jresult ;
75678   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75679   float result;
75680
75681   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75682   {
75683     try {
75684       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75685     } catch (std::out_of_range& e) {
75686       {
75687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75688       };
75689     } catch (std::exception& e) {
75690       {
75691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75692       };
75693     } catch (Dali::DaliException e) {
75694       {
75695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75696       };
75697     } catch (...) {
75698       {
75699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75700       };
75701     }
75702   }
75703
75704   jresult = result;
75705   return jresult;
75706 }
75707
75708
75709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75710   float jresult ;
75711   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75712   float result;
75713
75714   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75715   {
75716     try {
75717       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75718     } catch (std::out_of_range& e) {
75719       {
75720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75721       };
75722     } catch (std::exception& e) {
75723       {
75724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75725       };
75726     } catch (Dali::DaliException e) {
75727       {
75728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75729       };
75730     } catch (...) {
75731       {
75732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75733       };
75734     }
75735   }
75736
75737   jresult = result;
75738   return jresult;
75739 }
75740
75741
75742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75743   float jresult ;
75744   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75745   float result;
75746
75747   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75748   {
75749     try {
75750       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75751     } catch (std::out_of_range& e) {
75752       {
75753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75754       };
75755     } catch (std::exception& e) {
75756       {
75757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75758       };
75759     } catch (Dali::DaliException e) {
75760       {
75761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75762       };
75763     } catch (...) {
75764       {
75765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75766       };
75767     }
75768   }
75769
75770   jresult = result;
75771   return jresult;
75772 }
75773
75774
75775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75776   int jresult ;
75777   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75778   int arg2 ;
75779   int arg3 ;
75780   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75781   bool arg5 ;
75782   int result;
75783
75784   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75785   arg2 = (int)jarg2;
75786   arg3 = (int)jarg3;
75787   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75788   arg5 = jarg5 ? true : false;
75789   {
75790     try {
75791       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75792     } catch (std::out_of_range& e) {
75793       {
75794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75795       };
75796     } catch (std::exception& e) {
75797       {
75798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75799       };
75800     } catch (Dali::DaliException e) {
75801       {
75802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75803       };
75804     } catch (...) {
75805       {
75806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75807       };
75808     }
75809   }
75810
75811   jresult = result;
75812   return jresult;
75813 }
75814
75815
75816 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75817   float jresult ;
75818   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75819   float result;
75820
75821   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75822   {
75823     try {
75824       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75825     } catch (std::out_of_range& e) {
75826       {
75827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75828       };
75829     } catch (std::exception& e) {
75830       {
75831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75832       };
75833     } catch (Dali::DaliException e) {
75834       {
75835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75836       };
75837     } catch (...) {
75838       {
75839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75840       };
75841     }
75842   }
75843
75844   jresult = result;
75845   return jresult;
75846 }
75847
75848
75849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75850   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75851   Dali::Actor *arg2 = 0 ;
75852   int arg3 ;
75853   Dali::Vector3 *arg4 = 0 ;
75854   Dali::Actor *arg5 = 0 ;
75855
75856   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75857   arg2 = (Dali::Actor *)jarg2;
75858   if (!arg2) {
75859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75860     return ;
75861   }
75862   arg3 = (int)jarg3;
75863   arg4 = (Dali::Vector3 *)jarg4;
75864   if (!arg4) {
75865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75866     return ;
75867   }
75868   arg5 = (Dali::Actor *)jarg5;
75869   if (!arg5) {
75870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75871     return ;
75872   }
75873   {
75874     try {
75875       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75876     } catch (std::out_of_range& e) {
75877       {
75878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75879       };
75880     } catch (std::exception& e) {
75881       {
75882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75883       };
75884     } catch (Dali::DaliException e) {
75885       {
75886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75887       };
75888     } catch (...) {
75889       {
75890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75891       };
75892     }
75893   }
75894
75895 }
75896
75897
75898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75899   void * jresult ;
75900   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75901   int arg2 ;
75902   float arg3 ;
75903   Dali::Vector3 *arg4 = 0 ;
75904   Dali::Vector3 result;
75905
75906   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75907   arg2 = (int)jarg2;
75908   arg3 = (float)jarg3;
75909   arg4 = (Dali::Vector3 *)jarg4;
75910   if (!arg4) {
75911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75912     return 0;
75913   }
75914   {
75915     try {
75916       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75917     } catch (std::out_of_range& e) {
75918       {
75919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75920       };
75921     } catch (std::exception& e) {
75922       {
75923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75924       };
75925     } catch (Dali::DaliException e) {
75926       {
75927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75928       };
75929     } catch (...) {
75930       {
75931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75932       };
75933     }
75934   }
75935
75936   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75937   return jresult;
75938 }
75939
75940
75941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75942   void * jresult ;
75943   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75944   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75945
75946   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75947   {
75948     try {
75949       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75950     } catch (std::out_of_range& e) {
75951       {
75952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75953       };
75954     } catch (std::exception& e) {
75955       {
75956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75957       };
75958     } catch (Dali::DaliException e) {
75959       {
75960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75961       };
75962     } catch (...) {
75963       {
75964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75965       };
75966     }
75967   }
75968
75969   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75970   return jresult;
75971 }
75972
75973
75974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75975   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75976
75977   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75978   {
75979     try {
75980       delete arg1;
75981     } catch (std::out_of_range& e) {
75982       {
75983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75984       };
75985     } catch (std::exception& e) {
75986       {
75987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75988       };
75989     } catch (Dali::DaliException e) {
75990       {
75991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75992       };
75993     } catch (...) {
75994       {
75995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75996       };
75997     }
75998   }
75999
76000 }
76001
76002
76003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
76004   unsigned int jresult ;
76005   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76006   unsigned int result;
76007
76008   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76009   {
76010     try {
76011       result = (unsigned int)(arg1)->GetNumberOfItems();
76012     } catch (std::out_of_range& e) {
76013       {
76014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76015       };
76016     } catch (std::exception& e) {
76017       {
76018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76019       };
76020     } catch (Dali::DaliException e) {
76021       {
76022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76023       };
76024     } catch (...) {
76025       {
76026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76027       };
76028     }
76029   }
76030
76031   jresult = result;
76032   return jresult;
76033 }
76034
76035
76036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
76037   void * jresult ;
76038   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76039   unsigned int arg2 ;
76040   Dali::Actor result;
76041
76042   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76043   arg2 = (unsigned int)jarg2;
76044   {
76045     try {
76046       result = (arg1)->NewItem(arg2);
76047     } catch (std::out_of_range& e) {
76048       {
76049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76050       };
76051     } catch (std::exception& e) {
76052       {
76053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76054       };
76055     } catch (Dali::DaliException e) {
76056       {
76057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76058       };
76059     } catch (...) {
76060       {
76061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76062       };
76063     }
76064   }
76065
76066   jresult = new Dali::Actor((const Dali::Actor &)result);
76067   return jresult;
76068 }
76069
76070
76071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
76072   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76073   unsigned int arg2 ;
76074   Dali::Actor arg3 ;
76075   Dali::Actor *argp3 ;
76076
76077   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76078   arg2 = (unsigned int)jarg2;
76079   argp3 = (Dali::Actor *)jarg3;
76080   if (!argp3) {
76081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76082     return ;
76083   }
76084   arg3 = *argp3;
76085   {
76086     try {
76087       (arg1)->ItemReleased(arg2,arg3);
76088     } catch (std::out_of_range& e) {
76089       {
76090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76091       };
76092     } catch (std::exception& e) {
76093       {
76094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76095       };
76096     } catch (Dali::DaliException e) {
76097       {
76098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76099       };
76100     } catch (...) {
76101       {
76102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76103       };
76104     }
76105   }
76106
76107 }
76108
76109
76110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
76111   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76112   unsigned int arg2 ;
76113   Dali::Actor arg3 ;
76114   Dali::Actor *argp3 ;
76115
76116   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76117   arg2 = (unsigned int)jarg2;
76118   argp3 = (Dali::Actor *)jarg3;
76119   if (!argp3) {
76120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76121     return ;
76122   }
76123   arg3 = *argp3;
76124   {
76125     try {
76126       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
76127     } catch (std::out_of_range& e) {
76128       {
76129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76130       };
76131     } catch (std::exception& e) {
76132       {
76133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76134       };
76135     } catch (Dali::DaliException e) {
76136       {
76137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76138       };
76139     } catch (...) {
76140       {
76141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76142       };
76143     }
76144   }
76145
76146 }
76147
76148
76149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
76150   void * jresult ;
76151   Dali::Toolkit::ItemFactory *result = 0 ;
76152
76153   {
76154     try {
76155       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
76156     } catch (std::out_of_range& e) {
76157       {
76158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76159       };
76160     } catch (std::exception& e) {
76161       {
76162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76163       };
76164     } catch (Dali::DaliException e) {
76165       {
76166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76167       };
76168     } catch (...) {
76169       {
76170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76171       };
76172     }
76173   }
76174
76175   jresult = (void *)result;
76176   return jresult;
76177 }
76178
76179
76180 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) {
76181   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
76182   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
76183   if (director) {
76184     director->swig_connect_director(callback0, callback1, callback2);
76185   }
76186 }
76187
76188
76189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
76190   int jresult ;
76191   int result;
76192
76193   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
76194   jresult = (int)result;
76195   return jresult;
76196 }
76197
76198
76199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
76200   int jresult ;
76201   int result;
76202
76203   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
76204   jresult = (int)result;
76205   return jresult;
76206 }
76207
76208
76209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
76210   int jresult ;
76211   int result;
76212
76213   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
76214   jresult = (int)result;
76215   return jresult;
76216 }
76217
76218
76219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
76220   int jresult ;
76221   int result;
76222
76223   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
76224   jresult = (int)result;
76225   return jresult;
76226 }
76227
76228
76229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
76230   int jresult ;
76231   int result;
76232
76233   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
76234   jresult = (int)result;
76235   return jresult;
76236 }
76237
76238
76239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
76240   int jresult ;
76241   int result;
76242
76243   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
76244   jresult = (int)result;
76245   return jresult;
76246 }
76247
76248
76249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
76250   int jresult ;
76251   int result;
76252
76253   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
76254   jresult = (int)result;
76255   return jresult;
76256 }
76257
76258
76259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
76260   int jresult ;
76261   int result;
76262
76263   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
76264   jresult = (int)result;
76265   return jresult;
76266 }
76267
76268
76269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
76270   int jresult ;
76271   int result;
76272
76273   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
76274   jresult = (int)result;
76275   return jresult;
76276 }
76277
76278
76279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
76280   int jresult ;
76281   int result;
76282
76283   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
76284   jresult = (int)result;
76285   return jresult;
76286 }
76287
76288
76289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
76290   int jresult ;
76291   int result;
76292
76293   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
76294   jresult = (int)result;
76295   return jresult;
76296 }
76297
76298
76299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
76300   void * jresult ;
76301   Dali::Toolkit::ItemView::Property *result = 0 ;
76302
76303   {
76304     try {
76305       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
76306     } catch (std::out_of_range& e) {
76307       {
76308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76309       };
76310     } catch (std::exception& e) {
76311       {
76312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76313       };
76314     } catch (Dali::DaliException e) {
76315       {
76316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76317       };
76318     } catch (...) {
76319       {
76320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76321       };
76322     }
76323   }
76324
76325   jresult = (void *)result;
76326   return jresult;
76327 }
76328
76329
76330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
76331   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
76332
76333   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
76334   {
76335     try {
76336       delete arg1;
76337     } catch (std::out_of_range& e) {
76338       {
76339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76340       };
76341     } catch (std::exception& e) {
76342       {
76343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76344       };
76345     } catch (Dali::DaliException e) {
76346       {
76347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76348       };
76349     } catch (...) {
76350       {
76351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76352       };
76353     }
76354   }
76355
76356 }
76357
76358
76359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
76360   void * jresult ;
76361   Dali::Toolkit::ItemView *result = 0 ;
76362
76363   {
76364     try {
76365       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
76366     } catch (std::out_of_range& e) {
76367       {
76368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76369       };
76370     } catch (std::exception& e) {
76371       {
76372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76373       };
76374     } catch (Dali::DaliException e) {
76375       {
76376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76377       };
76378     } catch (...) {
76379       {
76380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76381       };
76382     }
76383   }
76384
76385   jresult = (void *)result;
76386   return jresult;
76387 }
76388
76389
76390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
76391   void * jresult ;
76392   Dali::Toolkit::ItemView *arg1 = 0 ;
76393   Dali::Toolkit::ItemView *result = 0 ;
76394
76395   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76396   if (!arg1) {
76397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76398     return 0;
76399   }
76400   {
76401     try {
76402       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
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_ItemView_Assign(void * jarg1, void * jarg2) {
76428   void * jresult ;
76429   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76430   Dali::Toolkit::ItemView *arg2 = 0 ;
76431   Dali::Toolkit::ItemView *result = 0 ;
76432
76433   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76434   arg2 = (Dali::Toolkit::ItemView *)jarg2;
76435   if (!arg2) {
76436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76437     return 0;
76438   }
76439   {
76440     try {
76441       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
76442     } catch (std::out_of_range& e) {
76443       {
76444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76445       };
76446     } catch (std::exception& e) {
76447       {
76448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76449       };
76450     } catch (Dali::DaliException e) {
76451       {
76452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76453       };
76454     } catch (...) {
76455       {
76456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76457       };
76458     }
76459   }
76460
76461   jresult = (void *)result;
76462   return jresult;
76463 }
76464
76465
76466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
76467   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76468
76469   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76470   {
76471     try {
76472       delete arg1;
76473     } catch (std::out_of_range& e) {
76474       {
76475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76476       };
76477     } catch (std::exception& e) {
76478       {
76479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76480       };
76481     } catch (Dali::DaliException e) {
76482       {
76483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76484       };
76485     } catch (...) {
76486       {
76487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76488       };
76489     }
76490   }
76491
76492 }
76493
76494
76495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
76496   void * jresult ;
76497   Dali::Toolkit::ItemFactory *arg1 = 0 ;
76498   Dali::Toolkit::ItemView result;
76499
76500   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76501   if (!arg1) {
76502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76503     return 0;
76504   }
76505   {
76506     try {
76507       result = Dali::Toolkit::ItemView::New(*arg1);
76508     } catch (std::out_of_range& e) {
76509       {
76510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76511       };
76512     } catch (std::exception& e) {
76513       {
76514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76515       };
76516     } catch (Dali::DaliException e) {
76517       {
76518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76519       };
76520     } catch (...) {
76521       {
76522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76523       };
76524     }
76525   }
76526
76527   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76528   return jresult;
76529 }
76530
76531
76532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76533   void * jresult ;
76534   Dali::BaseHandle arg1 ;
76535   Dali::BaseHandle *argp1 ;
76536   Dali::Toolkit::ItemView result;
76537
76538   argp1 = (Dali::BaseHandle *)jarg1;
76539   if (!argp1) {
76540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76541     return 0;
76542   }
76543   arg1 = *argp1;
76544   {
76545     try {
76546       result = Dali::Toolkit::ItemView::DownCast(arg1);
76547     } catch (std::out_of_range& e) {
76548       {
76549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76550       };
76551     } catch (std::exception& e) {
76552       {
76553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76554       };
76555     } catch (Dali::DaliException e) {
76556       {
76557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76558       };
76559     } catch (...) {
76560       {
76561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76562       };
76563     }
76564   }
76565
76566   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76567   return jresult;
76568 }
76569
76570
76571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76572   unsigned int jresult ;
76573   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76574   unsigned int result;
76575
76576   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76577   {
76578     try {
76579       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76580     } catch (std::out_of_range& e) {
76581       {
76582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76583       };
76584     } catch (std::exception& e) {
76585       {
76586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76587       };
76588     } catch (Dali::DaliException e) {
76589       {
76590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76591       };
76592     } catch (...) {
76593       {
76594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76595       };
76596     }
76597   }
76598
76599   jresult = result;
76600   return jresult;
76601 }
76602
76603
76604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76605   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76606   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76607
76608   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76609   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76610   if (!arg2) {
76611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76612     return ;
76613   }
76614   {
76615     try {
76616       (arg1)->AddLayout(*arg2);
76617     } catch (std::out_of_range& e) {
76618       {
76619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76620       };
76621     } catch (std::exception& e) {
76622       {
76623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76624       };
76625     } catch (Dali::DaliException e) {
76626       {
76627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76628       };
76629     } catch (...) {
76630       {
76631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76632       };
76633     }
76634   }
76635
76636 }
76637
76638
76639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76640   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76641   unsigned int arg2 ;
76642
76643   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76644   arg2 = (unsigned int)jarg2;
76645   {
76646     try {
76647       (arg1)->RemoveLayout(arg2);
76648     } catch (std::out_of_range& e) {
76649       {
76650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76651       };
76652     } catch (std::exception& e) {
76653       {
76654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76655       };
76656     } catch (Dali::DaliException e) {
76657       {
76658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76659       };
76660     } catch (...) {
76661       {
76662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76663       };
76664     }
76665   }
76666
76667 }
76668
76669
76670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76671   void * jresult ;
76672   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76673   unsigned int arg2 ;
76674   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76675
76676   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76677   arg2 = (unsigned int)jarg2;
76678   {
76679     try {
76680       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76681     } catch (std::out_of_range& e) {
76682       {
76683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76684       };
76685     } catch (std::exception& e) {
76686       {
76687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76688       };
76689     } catch (Dali::DaliException e) {
76690       {
76691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76692       };
76693     } catch (...) {
76694       {
76695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76696       };
76697     }
76698   }
76699
76700   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76701   return jresult;
76702 }
76703
76704
76705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76706   void * jresult ;
76707   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76708   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76709
76710   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76711   {
76712     try {
76713       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76714     } catch (std::out_of_range& e) {
76715       {
76716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76717       };
76718     } catch (std::exception& e) {
76719       {
76720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76721       };
76722     } catch (Dali::DaliException e) {
76723       {
76724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76725       };
76726     } catch (...) {
76727       {
76728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76729       };
76730     }
76731   }
76732
76733   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76734   return jresult;
76735 }
76736
76737
76738 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76739   float jresult ;
76740   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76741   Dali::Toolkit::ItemId arg2 ;
76742   float result;
76743
76744   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76745   arg2 = (Dali::Toolkit::ItemId)jarg2;
76746   {
76747     try {
76748       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76749     } catch (std::out_of_range& e) {
76750       {
76751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76752       };
76753     } catch (std::exception& e) {
76754       {
76755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76756       };
76757     } catch (Dali::DaliException e) {
76758       {
76759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76760       };
76761     } catch (...) {
76762       {
76763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76764       };
76765     }
76766   }
76767
76768   jresult = result;
76769   return jresult;
76770 }
76771
76772
76773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76774   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76775   unsigned int arg2 ;
76776   Dali::Vector3 arg3 ;
76777   float arg4 ;
76778   Dali::Vector3 *argp3 ;
76779
76780   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76781   arg2 = (unsigned int)jarg2;
76782   argp3 = (Dali::Vector3 *)jarg3;
76783   if (!argp3) {
76784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76785     return ;
76786   }
76787   arg3 = *argp3;
76788   arg4 = (float)jarg4;
76789   {
76790     try {
76791       (arg1)->ActivateLayout(arg2,arg3,arg4);
76792     } catch (std::out_of_range& e) {
76793       {
76794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76795       };
76796     } catch (std::exception& e) {
76797       {
76798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76799       };
76800     } catch (Dali::DaliException e) {
76801       {
76802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76803       };
76804     } catch (...) {
76805       {
76806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76807       };
76808     }
76809   }
76810
76811 }
76812
76813
76814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76815   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76816
76817   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76818   {
76819     try {
76820       (arg1)->DeactivateCurrentLayout();
76821     } catch (std::out_of_range& e) {
76822       {
76823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76824       };
76825     } catch (std::exception& e) {
76826       {
76827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76828       };
76829     } catch (Dali::DaliException e) {
76830       {
76831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76832       };
76833     } catch (...) {
76834       {
76835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76836       };
76837     }
76838   }
76839
76840 }
76841
76842
76843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76844   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76845   float arg2 ;
76846
76847   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76848   arg2 = (float)jarg2;
76849   {
76850     try {
76851       (arg1)->SetMinimumSwipeSpeed(arg2);
76852     } catch (std::out_of_range& e) {
76853       {
76854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76855       };
76856     } catch (std::exception& e) {
76857       {
76858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76859       };
76860     } catch (Dali::DaliException e) {
76861       {
76862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76863       };
76864     } catch (...) {
76865       {
76866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76867       };
76868     }
76869   }
76870
76871 }
76872
76873
76874 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76875   float jresult ;
76876   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76877   float result;
76878
76879   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76880   {
76881     try {
76882       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76883     } catch (std::out_of_range& e) {
76884       {
76885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76886       };
76887     } catch (std::exception& e) {
76888       {
76889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76890       };
76891     } catch (Dali::DaliException e) {
76892       {
76893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76894       };
76895     } catch (...) {
76896       {
76897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76898       };
76899     }
76900   }
76901
76902   jresult = result;
76903   return jresult;
76904 }
76905
76906
76907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76908   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76909   float arg2 ;
76910
76911   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76912   arg2 = (float)jarg2;
76913   {
76914     try {
76915       (arg1)->SetMinimumSwipeDistance(arg2);
76916     } catch (std::out_of_range& e) {
76917       {
76918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76919       };
76920     } catch (std::exception& e) {
76921       {
76922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76923       };
76924     } catch (Dali::DaliException e) {
76925       {
76926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76927       };
76928     } catch (...) {
76929       {
76930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76931       };
76932     }
76933   }
76934
76935 }
76936
76937
76938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76939   float jresult ;
76940   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76941   float result;
76942
76943   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76944   {
76945     try {
76946       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76947     } catch (std::out_of_range& e) {
76948       {
76949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76950       };
76951     } catch (std::exception& e) {
76952       {
76953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76954       };
76955     } catch (Dali::DaliException e) {
76956       {
76957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76958       };
76959     } catch (...) {
76960       {
76961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76962       };
76963     }
76964   }
76965
76966   jresult = result;
76967   return jresult;
76968 }
76969
76970
76971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76972   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76973   float arg2 ;
76974
76975   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76976   arg2 = (float)jarg2;
76977   {
76978     try {
76979       (arg1)->SetWheelScrollDistanceStep(arg2);
76980     } catch (std::out_of_range& e) {
76981       {
76982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76983       };
76984     } catch (std::exception& e) {
76985       {
76986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76987       };
76988     } catch (Dali::DaliException e) {
76989       {
76990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76991       };
76992     } catch (...) {
76993       {
76994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76995       };
76996     }
76997   }
76998
76999 }
77000
77001
77002 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
77003   float jresult ;
77004   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77005   float result;
77006
77007   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77008   {
77009     try {
77010       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
77011     } catch (std::out_of_range& e) {
77012       {
77013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77014       };
77015     } catch (std::exception& e) {
77016       {
77017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77018       };
77019     } catch (Dali::DaliException e) {
77020       {
77021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77022       };
77023     } catch (...) {
77024       {
77025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77026       };
77027     }
77028   }
77029
77030   jresult = result;
77031   return jresult;
77032 }
77033
77034
77035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
77036   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77037   bool arg2 ;
77038
77039   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77040   arg2 = jarg2 ? true : false;
77041   {
77042     try {
77043       (arg1)->SetAnchoring(arg2);
77044     } catch (std::out_of_range& e) {
77045       {
77046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77047       };
77048     } catch (std::exception& e) {
77049       {
77050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77051       };
77052     } catch (Dali::DaliException e) {
77053       {
77054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77055       };
77056     } catch (...) {
77057       {
77058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77059       };
77060     }
77061   }
77062
77063 }
77064
77065 //// ========================= end of part 3 =============================
77066
77067 //// ========================== start part 4 ===============================
77068
77069
77070 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
77071   unsigned int jresult ;
77072   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77073   bool result;
77074
77075   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77076   {
77077     try {
77078       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
77079     } catch (std::out_of_range& e) {
77080       {
77081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77082       };
77083     } catch (std::exception& e) {
77084       {
77085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77086       };
77087     } catch (Dali::DaliException e) {
77088       {
77089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77090       };
77091     } catch (...) {
77092       {
77093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77094       };
77095     }
77096   }
77097
77098   jresult = result;
77099   return jresult;
77100 }
77101
77102
77103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
77104   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77105   float arg2 ;
77106
77107   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77108   arg2 = (float)jarg2;
77109   {
77110     try {
77111       (arg1)->SetAnchoringDuration(arg2);
77112     } catch (std::out_of_range& e) {
77113       {
77114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77115       };
77116     } catch (std::exception& e) {
77117       {
77118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77119       };
77120     } catch (Dali::DaliException e) {
77121       {
77122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77123       };
77124     } catch (...) {
77125       {
77126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77127       };
77128     }
77129   }
77130
77131 }
77132
77133
77134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
77135   float jresult ;
77136   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77137   float result;
77138
77139   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77140   {
77141     try {
77142       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
77143     } catch (std::out_of_range& e) {
77144       {
77145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77146       };
77147     } catch (std::exception& e) {
77148       {
77149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77150       };
77151     } catch (Dali::DaliException e) {
77152       {
77153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77154       };
77155     } catch (...) {
77156       {
77157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77158       };
77159     }
77160   }
77161
77162   jresult = result;
77163   return jresult;
77164 }
77165
77166
77167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
77168   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77169   Dali::Toolkit::ItemId arg2 ;
77170   float arg3 ;
77171
77172   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77173   arg2 = (Dali::Toolkit::ItemId)jarg2;
77174   arg3 = (float)jarg3;
77175   {
77176     try {
77177       (arg1)->ScrollToItem(arg2,arg3);
77178     } catch (std::out_of_range& e) {
77179       {
77180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77181       };
77182     } catch (std::exception& e) {
77183       {
77184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77185       };
77186     } catch (Dali::DaliException e) {
77187       {
77188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77189       };
77190     } catch (...) {
77191       {
77192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77193       };
77194     }
77195   }
77196
77197 }
77198
77199
77200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
77201   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77202   float arg2 ;
77203
77204   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77205   arg2 = (float)jarg2;
77206   {
77207     try {
77208       (arg1)->SetRefreshInterval(arg2);
77209     } catch (std::out_of_range& e) {
77210       {
77211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77212       };
77213     } catch (std::exception& e) {
77214       {
77215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77216       };
77217     } catch (Dali::DaliException e) {
77218       {
77219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77220       };
77221     } catch (...) {
77222       {
77223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77224       };
77225     }
77226   }
77227
77228 }
77229
77230
77231 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
77232   float jresult ;
77233   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77234   float result;
77235
77236   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77237   {
77238     try {
77239       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
77240     } catch (std::out_of_range& e) {
77241       {
77242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77243       };
77244     } catch (std::exception& e) {
77245       {
77246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77247       };
77248     } catch (Dali::DaliException e) {
77249       {
77250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77251       };
77252     } catch (...) {
77253       {
77254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77255       };
77256     }
77257   }
77258
77259   jresult = result;
77260   return jresult;
77261 }
77262
77263
77264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
77265   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77266
77267   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77268   {
77269     try {
77270       (arg1)->Refresh();
77271     } catch (std::out_of_range& e) {
77272       {
77273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77274       };
77275     } catch (std::exception& e) {
77276       {
77277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77278       };
77279     } catch (Dali::DaliException e) {
77280       {
77281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77282       };
77283     } catch (...) {
77284       {
77285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77286       };
77287     }
77288   }
77289
77290 }
77291
77292
77293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
77294   void * jresult ;
77295   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77296   Dali::Toolkit::ItemId arg2 ;
77297   Dali::Actor result;
77298
77299   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77300   arg2 = (Dali::Toolkit::ItemId)jarg2;
77301   {
77302     try {
77303       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
77304     } catch (std::out_of_range& e) {
77305       {
77306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77307       };
77308     } catch (std::exception& e) {
77309       {
77310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77311       };
77312     } catch (Dali::DaliException e) {
77313       {
77314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77315       };
77316     } catch (...) {
77317       {
77318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77319       };
77320     }
77321   }
77322
77323   jresult = new Dali::Actor((const Dali::Actor &)result);
77324   return jresult;
77325 }
77326
77327
77328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
77329   unsigned int jresult ;
77330   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77331   Dali::Actor arg2 ;
77332   Dali::Actor *argp2 ;
77333   Dali::Toolkit::ItemId result;
77334
77335   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77336   argp2 = (Dali::Actor *)jarg2;
77337   if (!argp2) {
77338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77339     return 0;
77340   }
77341   arg2 = *argp2;
77342   {
77343     try {
77344       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
77345     } catch (std::out_of_range& e) {
77346       {
77347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77348       };
77349     } catch (std::exception& e) {
77350       {
77351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77352       };
77353     } catch (Dali::DaliException e) {
77354       {
77355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77356       };
77357     } catch (...) {
77358       {
77359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77360       };
77361     }
77362   }
77363
77364   jresult = result;
77365   return jresult;
77366 }
77367
77368
77369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
77370   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77371   Dali::Toolkit::Item arg2 ;
77372   float arg3 ;
77373   Dali::Toolkit::Item *argp2 ;
77374
77375   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77376   argp2 = (Dali::Toolkit::Item *)jarg2;
77377   if (!argp2) {
77378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77379     return ;
77380   }
77381   arg2 = *argp2;
77382   arg3 = (float)jarg3;
77383   {
77384     try {
77385       (arg1)->InsertItem(arg2,arg3);
77386     } catch (std::out_of_range& e) {
77387       {
77388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77389       };
77390     } catch (std::exception& e) {
77391       {
77392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77393       };
77394     } catch (Dali::DaliException e) {
77395       {
77396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77397       };
77398     } catch (...) {
77399       {
77400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77401       };
77402     }
77403   }
77404
77405 }
77406
77407
77408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
77409   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77410   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77411   float arg3 ;
77412
77413   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77414   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77415   if (!arg2) {
77416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77417     return ;
77418   }
77419   arg3 = (float)jarg3;
77420   {
77421     try {
77422       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*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_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
77446   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77447   Dali::Toolkit::ItemId arg2 ;
77448   float arg3 ;
77449
77450   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77451   arg2 = (Dali::Toolkit::ItemId)jarg2;
77452   arg3 = (float)jarg3;
77453   {
77454     try {
77455       (arg1)->RemoveItem(arg2,arg3);
77456     } catch (std::out_of_range& e) {
77457       {
77458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77459       };
77460     } catch (std::exception& e) {
77461       {
77462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77463       };
77464     } catch (Dali::DaliException e) {
77465       {
77466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77467       };
77468     } catch (...) {
77469       {
77470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77471       };
77472     }
77473   }
77474
77475 }
77476
77477
77478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
77479   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77480   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
77481   float arg3 ;
77482
77483   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77484   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
77485   if (!arg2) {
77486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
77487     return ;
77488   }
77489   arg3 = (float)jarg3;
77490   {
77491     try {
77492       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*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_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77516   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77517   Dali::Toolkit::Item arg2 ;
77518   float arg3 ;
77519   Dali::Toolkit::Item *argp2 ;
77520
77521   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77522   argp2 = (Dali::Toolkit::Item *)jarg2;
77523   if (!argp2) {
77524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77525     return ;
77526   }
77527   arg2 = *argp2;
77528   arg3 = (float)jarg3;
77529   {
77530     try {
77531       (arg1)->ReplaceItem(arg2,arg3);
77532     } catch (std::out_of_range& e) {
77533       {
77534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77535       };
77536     } catch (std::exception& e) {
77537       {
77538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77539       };
77540     } catch (Dali::DaliException e) {
77541       {
77542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77543       };
77544     } catch (...) {
77545       {
77546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77547       };
77548     }
77549   }
77550
77551 }
77552
77553
77554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77555   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77556   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77557   float arg3 ;
77558
77559   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77560   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77561   if (!arg2) {
77562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77563     return ;
77564   }
77565   arg3 = (float)jarg3;
77566   {
77567     try {
77568       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*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_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77592   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77593   Dali::Vector3 *arg2 = 0 ;
77594
77595   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77596   arg2 = (Dali::Vector3 *)jarg2;
77597   if (!arg2) {
77598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77599     return ;
77600   }
77601   {
77602     try {
77603       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77604     } catch (std::out_of_range& e) {
77605       {
77606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77607       };
77608     } catch (std::exception& e) {
77609       {
77610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77611       };
77612     } catch (Dali::DaliException e) {
77613       {
77614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77615       };
77616     } catch (...) {
77617       {
77618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77619       };
77620     }
77621   }
77622
77623 }
77624
77625
77626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77627   void * jresult ;
77628   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77629   Dali::Vector3 result;
77630
77631   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77632   {
77633     try {
77634       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77635     } catch (std::out_of_range& e) {
77636       {
77637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77638       };
77639     } catch (std::exception& e) {
77640       {
77641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77642       };
77643     } catch (Dali::DaliException e) {
77644       {
77645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77646       };
77647     } catch (...) {
77648       {
77649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77650       };
77651     }
77652   }
77653
77654   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77655   return jresult;
77656 }
77657
77658
77659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77660   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77661   Dali::Vector3 *arg2 = 0 ;
77662
77663   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77664   arg2 = (Dali::Vector3 *)jarg2;
77665   if (!arg2) {
77666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77667     return ;
77668   }
77669   {
77670     try {
77671       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77672     } catch (std::out_of_range& e) {
77673       {
77674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77675       };
77676     } catch (std::exception& e) {
77677       {
77678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77679       };
77680     } catch (Dali::DaliException e) {
77681       {
77682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77683       };
77684     } catch (...) {
77685       {
77686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77687       };
77688     }
77689   }
77690
77691 }
77692
77693
77694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77695   void * jresult ;
77696   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77697   Dali::Vector3 result;
77698
77699   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77700   {
77701     try {
77702       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77703     } catch (std::out_of_range& e) {
77704       {
77705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77706       };
77707     } catch (std::exception& e) {
77708       {
77709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77710       };
77711     } catch (Dali::DaliException e) {
77712       {
77713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77714       };
77715     } catch (...) {
77716       {
77717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77718       };
77719     }
77720   }
77721
77722   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77723   return jresult;
77724 }
77725
77726
77727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77728   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77729   Dali::Toolkit::ItemRange *arg2 = 0 ;
77730
77731   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77732   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77733   if (!arg2) {
77734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77735     return ;
77736   }
77737   {
77738     try {
77739       (arg1)->GetItemsRange(*arg2);
77740     } catch (std::out_of_range& e) {
77741       {
77742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77743       };
77744     } catch (std::exception& e) {
77745       {
77746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77747       };
77748     } catch (Dali::DaliException e) {
77749       {
77750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77751       };
77752     } catch (...) {
77753       {
77754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77755       };
77756     }
77757   }
77758
77759 }
77760
77761
77762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77763   void * jresult ;
77764   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77765   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77766
77767   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77768   {
77769     try {
77770       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77771     } catch (std::out_of_range& e) {
77772       {
77773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77774       };
77775     } catch (std::exception& e) {
77776       {
77777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77778       };
77779     } catch (Dali::DaliException e) {
77780       {
77781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77782       };
77783     } catch (...) {
77784       {
77785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77786       };
77787     }
77788   }
77789
77790   jresult = (void *)result;
77791   return jresult;
77792 }
77793
77794
77795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77796   Dali::Vector3 *arg1 = 0 ;
77797   PropertyInputContainer *arg2 = 0 ;
77798
77799   arg1 = (Dali::Vector3 *)jarg1;
77800   if (!arg1) {
77801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77802     return ;
77803   }
77804   arg2 = (PropertyInputContainer *)jarg2;
77805   if (!arg2) {
77806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77807     return ;
77808   }
77809   {
77810     try {
77811       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77812     } catch (std::out_of_range& e) {
77813       {
77814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77815       };
77816     } catch (std::exception& e) {
77817       {
77818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77819       };
77820     } catch (Dali::DaliException e) {
77821       {
77822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77823       };
77824     } catch (...) {
77825       {
77826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77827       };
77828     }
77829   }
77830
77831 }
77832
77833
77834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77835   Dali::Vector3 *arg1 = 0 ;
77836   PropertyInputContainer *arg2 = 0 ;
77837
77838   arg1 = (Dali::Vector3 *)jarg1;
77839   if (!arg1) {
77840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77841     return ;
77842   }
77843   arg2 = (PropertyInputContainer *)jarg2;
77844   if (!arg2) {
77845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77846     return ;
77847   }
77848   {
77849     try {
77850       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77851     } catch (std::out_of_range& e) {
77852       {
77853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77854       };
77855     } catch (std::exception& e) {
77856       {
77857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77858       };
77859     } catch (Dali::DaliException e) {
77860       {
77861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77862       };
77863     } catch (...) {
77864       {
77865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77866       };
77867     }
77868   }
77869
77870 }
77871
77872
77873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77874   void * jresult ;
77875   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77876
77877   {
77878     try {
77879       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77880     } catch (std::out_of_range& e) {
77881       {
77882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77883       };
77884     } catch (std::exception& e) {
77885       {
77886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77887       };
77888     } catch (Dali::DaliException e) {
77889       {
77890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77891       };
77892     } catch (...) {
77893       {
77894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77895       };
77896     }
77897   }
77898
77899   jresult = (void *)result;
77900   return jresult;
77901 }
77902
77903
77904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77905   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77906
77907   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77908   {
77909     try {
77910       delete arg1;
77911     } catch (std::out_of_range& e) {
77912       {
77913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77914       };
77915     } catch (std::exception& e) {
77916       {
77917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77918       };
77919     } catch (Dali::DaliException e) {
77920       {
77921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77922       };
77923     } catch (...) {
77924       {
77925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77926       };
77927     }
77928   }
77929
77930 }
77931
77932
77933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77934   void * jresult ;
77935   Dali::Path arg1 ;
77936   Dali::Vector3 *arg2 = 0 ;
77937   Dali::Property::Index arg3 ;
77938   Dali::Vector3 *arg4 = 0 ;
77939   unsigned int arg5 ;
77940   Dali::Path *argp1 ;
77941   Dali::Toolkit::ScrollViewPagePathEffect result;
77942
77943   argp1 = (Dali::Path *)jarg1;
77944   if (!argp1) {
77945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77946     return 0;
77947   }
77948   arg1 = *argp1;
77949   arg2 = (Dali::Vector3 *)jarg2;
77950   if (!arg2) {
77951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77952     return 0;
77953   }
77954   arg3 = (Dali::Property::Index)jarg3;
77955   arg4 = (Dali::Vector3 *)jarg4;
77956   if (!arg4) {
77957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77958     return 0;
77959   }
77960   arg5 = (unsigned int)jarg5;
77961   {
77962     try {
77963       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77964     } catch (std::out_of_range& e) {
77965       {
77966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77967       };
77968     } catch (std::exception& e) {
77969       {
77970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77971       };
77972     } catch (Dali::DaliException e) {
77973       {
77974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77975       };
77976     } catch (...) {
77977       {
77978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77979       };
77980     }
77981   }
77982
77983   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77984   return jresult;
77985 }
77986
77987
77988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77989   void * jresult ;
77990   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77991
77992   {
77993     try {
77994       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77995     } catch (std::out_of_range& e) {
77996       {
77997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77998       };
77999     } catch (std::exception& e) {
78000       {
78001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78002       };
78003     } catch (Dali::DaliException e) {
78004       {
78005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78006       };
78007     } catch (...) {
78008       {
78009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78010       };
78011     }
78012   }
78013
78014   jresult = (void *)result;
78015   return jresult;
78016 }
78017
78018
78019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
78020   void * jresult ;
78021   Dali::BaseHandle arg1 ;
78022   Dali::BaseHandle *argp1 ;
78023   Dali::Toolkit::ScrollViewPagePathEffect result;
78024
78025   argp1 = (Dali::BaseHandle *)jarg1;
78026   if (!argp1) {
78027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78028     return 0;
78029   }
78030   arg1 = *argp1;
78031   {
78032     try {
78033       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
78034     } catch (std::out_of_range& e) {
78035       {
78036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78037       };
78038     } catch (std::exception& e) {
78039       {
78040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78041       };
78042     } catch (Dali::DaliException e) {
78043       {
78044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78045       };
78046     } catch (...) {
78047       {
78048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78049       };
78050     }
78051   }
78052
78053   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
78054   return jresult;
78055 }
78056
78057
78058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
78059   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
78060   Dali::Actor arg2 ;
78061   unsigned int arg3 ;
78062   Dali::Actor *argp2 ;
78063
78064   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
78065   argp2 = (Dali::Actor *)jarg2;
78066   if (!argp2) {
78067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78068     return ;
78069   }
78070   arg2 = *argp2;
78071   arg3 = (unsigned int)jarg3;
78072   {
78073     try {
78074       (arg1)->ApplyToPage(arg2,arg3);
78075     } catch (std::out_of_range& e) {
78076       {
78077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78078       };
78079     } catch (std::exception& e) {
78080       {
78081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78082       };
78083     } catch (Dali::DaliException e) {
78084       {
78085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78086       };
78087     } catch (...) {
78088       {
78089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78090       };
78091     }
78092   }
78093
78094 }
78095
78096
78097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
78098   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
78099
78100   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
78101   {
78102     try {
78103       delete arg1;
78104     } catch (std::out_of_range& e) {
78105       {
78106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78107       };
78108     } catch (std::exception& e) {
78109       {
78110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78111       };
78112     } catch (Dali::DaliException e) {
78113       {
78114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78115       };
78116     } catch (...) {
78117       {
78118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78119       };
78120     }
78121   }
78122
78123 }
78124
78125
78126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
78127   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78128   Dali::Toolkit::ClampState arg2 ;
78129
78130   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78131   arg2 = (Dali::Toolkit::ClampState)jarg2;
78132   if (arg1) (arg1)->x = arg2;
78133 }
78134
78135
78136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
78137   int jresult ;
78138   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78139   Dali::Toolkit::ClampState result;
78140
78141   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78142   result = (Dali::Toolkit::ClampState) ((arg1)->x);
78143   jresult = (int)result;
78144   return jresult;
78145 }
78146
78147
78148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
78149   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78150   Dali::Toolkit::ClampState arg2 ;
78151
78152   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78153   arg2 = (Dali::Toolkit::ClampState)jarg2;
78154   if (arg1) (arg1)->y = arg2;
78155 }
78156
78157
78158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
78159   int jresult ;
78160   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78161   Dali::Toolkit::ClampState result;
78162
78163   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78164   result = (Dali::Toolkit::ClampState) ((arg1)->y);
78165   jresult = (int)result;
78166   return jresult;
78167 }
78168
78169
78170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
78171   void * jresult ;
78172   Dali::Toolkit::ClampState2D *result = 0 ;
78173
78174   {
78175     try {
78176       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
78177     } catch (std::out_of_range& e) {
78178       {
78179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78180       };
78181     } catch (std::exception& e) {
78182       {
78183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78184       };
78185     } catch (Dali::DaliException e) {
78186       {
78187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78188       };
78189     } catch (...) {
78190       {
78191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78192       };
78193     }
78194   }
78195
78196   jresult = (void *)result;
78197   return jresult;
78198 }
78199
78200
78201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
78202   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78203
78204   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78205   {
78206     try {
78207       delete arg1;
78208     } catch (std::out_of_range& e) {
78209       {
78210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78211       };
78212     } catch (std::exception& e) {
78213       {
78214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78215       };
78216     } catch (Dali::DaliException e) {
78217       {
78218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78219       };
78220     } catch (...) {
78221       {
78222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78223       };
78224     }
78225   }
78226
78227 }
78228
78229
78230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
78231   void * jresult ;
78232   float arg1 ;
78233   float arg2 ;
78234   bool arg3 ;
78235   Dali::Toolkit::RulerDomain *result = 0 ;
78236
78237   arg1 = (float)jarg1;
78238   arg2 = (float)jarg2;
78239   arg3 = jarg3 ? true : false;
78240   {
78241     try {
78242       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
78243     } catch (std::out_of_range& e) {
78244       {
78245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78246       };
78247     } catch (std::exception& e) {
78248       {
78249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78250       };
78251     } catch (Dali::DaliException e) {
78252       {
78253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78254       };
78255     } catch (...) {
78256       {
78257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78258       };
78259     }
78260   }
78261
78262   jresult = (void *)result;
78263   return jresult;
78264 }
78265
78266
78267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
78268   void * jresult ;
78269   float arg1 ;
78270   float arg2 ;
78271   Dali::Toolkit::RulerDomain *result = 0 ;
78272
78273   arg1 = (float)jarg1;
78274   arg2 = (float)jarg2;
78275   {
78276     try {
78277       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
78278     } catch (std::out_of_range& e) {
78279       {
78280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78281       };
78282     } catch (std::exception& e) {
78283       {
78284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78285       };
78286     } catch (Dali::DaliException e) {
78287       {
78288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78289       };
78290     } catch (...) {
78291       {
78292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78293       };
78294     }
78295   }
78296
78297   jresult = (void *)result;
78298   return jresult;
78299 }
78300
78301
78302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
78303   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78304   float arg2 ;
78305
78306   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78307   arg2 = (float)jarg2;
78308   if (arg1) (arg1)->min = arg2;
78309 }
78310
78311
78312 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
78313   float jresult ;
78314   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78315   float result;
78316
78317   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78318   result = (float) ((arg1)->min);
78319   jresult = result;
78320   return jresult;
78321 }
78322
78323
78324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
78325   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78326   float arg2 ;
78327
78328   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78329   arg2 = (float)jarg2;
78330   if (arg1) (arg1)->max = arg2;
78331 }
78332
78333
78334 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
78335   float jresult ;
78336   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78337   float result;
78338
78339   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78340   result = (float) ((arg1)->max);
78341   jresult = result;
78342   return jresult;
78343 }
78344
78345
78346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
78347   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78348   bool arg2 ;
78349
78350   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78351   arg2 = jarg2 ? true : false;
78352   if (arg1) (arg1)->enabled = arg2;
78353 }
78354
78355
78356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
78357   unsigned int jresult ;
78358   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78359   bool result;
78360
78361   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78362   result = (bool) ((arg1)->enabled);
78363   jresult = result;
78364   return jresult;
78365 }
78366
78367
78368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78369   float jresult ;
78370   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78371   float arg2 ;
78372   float arg3 ;
78373   float arg4 ;
78374   float result;
78375
78376   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78377   arg2 = (float)jarg2;
78378   arg3 = (float)jarg3;
78379   arg4 = (float)jarg4;
78380   {
78381     try {
78382       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
78383     } catch (std::out_of_range& e) {
78384       {
78385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78386       };
78387     } catch (std::exception& e) {
78388       {
78389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78390       };
78391     } catch (Dali::DaliException e) {
78392       {
78393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78394       };
78395     } catch (...) {
78396       {
78397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78398       };
78399     }
78400   }
78401
78402   jresult = result;
78403   return jresult;
78404 }
78405
78406
78407 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78408   float jresult ;
78409   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78410   float arg2 ;
78411   float arg3 ;
78412   float result;
78413
78414   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78415   arg2 = (float)jarg2;
78416   arg3 = (float)jarg3;
78417   {
78418     try {
78419       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
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_2(void * jarg1, float jarg2) {
78445   float jresult ;
78446   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78447   float arg2 ;
78448   float result;
78449
78450   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78451   arg2 = (float)jarg2;
78452   {
78453     try {
78454       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
78455     } catch (std::out_of_range& e) {
78456       {
78457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78458       };
78459     } catch (std::exception& e) {
78460       {
78461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78462       };
78463     } catch (Dali::DaliException e) {
78464       {
78465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78466       };
78467     } catch (...) {
78468       {
78469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78470       };
78471     }
78472   }
78473
78474   jresult = result;
78475   return jresult;
78476 }
78477
78478
78479 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78480   float jresult ;
78481   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78482   float arg2 ;
78483   float arg3 ;
78484   float arg4 ;
78485   Dali::Toolkit::ClampState *arg5 = 0 ;
78486   float result;
78487
78488   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78489   arg2 = (float)jarg2;
78490   arg3 = (float)jarg3;
78491   arg4 = (float)jarg4;
78492   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78493   if (!arg5) {
78494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78495     return 0;
78496   }
78497   {
78498     try {
78499       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78500     } catch (std::out_of_range& e) {
78501       {
78502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78503       };
78504     } catch (std::exception& e) {
78505       {
78506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78507       };
78508     } catch (Dali::DaliException e) {
78509       {
78510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78511       };
78512     } catch (...) {
78513       {
78514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78515       };
78516     }
78517   }
78518
78519   jresult = result;
78520   return jresult;
78521 }
78522
78523
78524 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
78525   float jresult ;
78526   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78527   float result;
78528
78529   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78530   {
78531     try {
78532       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
78533     } catch (std::out_of_range& e) {
78534       {
78535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78536       };
78537     } catch (std::exception& e) {
78538       {
78539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78540       };
78541     } catch (Dali::DaliException e) {
78542       {
78543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78544       };
78545     } catch (...) {
78546       {
78547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78548       };
78549     }
78550   }
78551
78552   jresult = result;
78553   return jresult;
78554 }
78555
78556
78557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78558   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78559
78560   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78561   {
78562     try {
78563       delete arg1;
78564     } catch (std::out_of_range& e) {
78565       {
78566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78567       };
78568     } catch (std::exception& e) {
78569       {
78570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78571       };
78572     } catch (Dali::DaliException e) {
78573       {
78574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78575       };
78576     } catch (...) {
78577       {
78578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78579       };
78580     }
78581   }
78582
78583 }
78584
78585
78586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78587   float jresult ;
78588   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78589   float arg2 ;
78590   float arg3 ;
78591   float result;
78592
78593   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78594   arg2 = (float)jarg2;
78595   arg3 = (float)jarg3;
78596   {
78597     try {
78598       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78599     } catch (std::out_of_range& e) {
78600       {
78601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78602       };
78603     } catch (std::exception& e) {
78604       {
78605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78606       };
78607     } catch (Dali::DaliException e) {
78608       {
78609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78610       };
78611     } catch (...) {
78612       {
78613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78614       };
78615     }
78616   }
78617
78618   jresult = result;
78619   return jresult;
78620 }
78621
78622
78623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78624   float jresult ;
78625   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78626   float arg2 ;
78627   float result;
78628
78629   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78630   arg2 = (float)jarg2;
78631   {
78632     try {
78633       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78634     } catch (std::out_of_range& e) {
78635       {
78636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78637       };
78638     } catch (std::exception& e) {
78639       {
78640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78641       };
78642     } catch (Dali::DaliException e) {
78643       {
78644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78645       };
78646     } catch (...) {
78647       {
78648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78649       };
78650     }
78651   }
78652
78653   jresult = result;
78654   return jresult;
78655 }
78656
78657
78658 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78659   float jresult ;
78660   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78661   unsigned int arg2 ;
78662   unsigned int *arg3 = 0 ;
78663   bool arg4 ;
78664   float result;
78665
78666   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78667   arg2 = (unsigned int)jarg2;
78668   arg3 = (unsigned int *)jarg3;
78669   arg4 = jarg4 ? true : false;
78670   {
78671     try {
78672       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78673     } catch (std::out_of_range& e) {
78674       {
78675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78676       };
78677     } catch (std::exception& e) {
78678       {
78679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78680       };
78681     } catch (Dali::DaliException e) {
78682       {
78683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78684       };
78685     } catch (...) {
78686       {
78687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78688       };
78689     }
78690   }
78691
78692   jresult = result;
78693   return jresult;
78694 }
78695
78696
78697 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78698   unsigned int jresult ;
78699   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78700   float arg2 ;
78701   bool arg3 ;
78702   unsigned int result;
78703
78704   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78705   arg2 = (float)jarg2;
78706   arg3 = jarg3 ? true : false;
78707   {
78708     try {
78709       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
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_GetTotalPages(void * jarg1) {
78735   unsigned int jresult ;
78736   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78737   unsigned int result;
78738
78739   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78740   {
78741     try {
78742       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78743     } catch (std::out_of_range& e) {
78744       {
78745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78746       };
78747     } catch (std::exception& e) {
78748       {
78749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78750       };
78751     } catch (Dali::DaliException e) {
78752       {
78753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78754       };
78755     } catch (...) {
78756       {
78757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78758       };
78759     }
78760   }
78761
78762   jresult = result;
78763   return jresult;
78764 }
78765
78766
78767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78768   int jresult ;
78769   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78770   Dali::Toolkit::Ruler::RulerType result;
78771
78772   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78773   {
78774     try {
78775       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78776     } catch (std::out_of_range& e) {
78777       {
78778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78779       };
78780     } catch (std::exception& e) {
78781       {
78782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78783       };
78784     } catch (Dali::DaliException e) {
78785       {
78786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78787       };
78788     } catch (...) {
78789       {
78790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78791       };
78792     }
78793   }
78794
78795   jresult = (int)result;
78796   return jresult;
78797 }
78798
78799
78800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78801   unsigned int jresult ;
78802   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78803   bool result;
78804
78805   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78806   {
78807     try {
78808       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78809     } catch (std::out_of_range& e) {
78810       {
78811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78812       };
78813     } catch (std::exception& e) {
78814       {
78815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78816       };
78817     } catch (Dali::DaliException e) {
78818       {
78819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78820       };
78821     } catch (...) {
78822       {
78823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78824       };
78825     }
78826   }
78827
78828   jresult = result;
78829   return jresult;
78830 }
78831
78832
78833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78834   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78835
78836   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78837   {
78838     try {
78839       (arg1)->Enable();
78840     } catch (std::out_of_range& e) {
78841       {
78842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78843       };
78844     } catch (std::exception& e) {
78845       {
78846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78847       };
78848     } catch (Dali::DaliException e) {
78849       {
78850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78851       };
78852     } catch (...) {
78853       {
78854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78855       };
78856     }
78857   }
78858
78859 }
78860
78861
78862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78863   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78864
78865   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78866   {
78867     try {
78868       (arg1)->Disable();
78869     } catch (std::out_of_range& e) {
78870       {
78871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78872       };
78873     } catch (std::exception& e) {
78874       {
78875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78876       };
78877     } catch (Dali::DaliException e) {
78878       {
78879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78880       };
78881     } catch (...) {
78882       {
78883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78884       };
78885     }
78886   }
78887
78888 }
78889
78890
78891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78892   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78893   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78894   Dali::Toolkit::RulerDomain *argp2 ;
78895
78896   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78897   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78898   if (!argp2) {
78899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78900     return ;
78901   }
78902   arg2 = *argp2;
78903   {
78904     try {
78905       (arg1)->SetDomain(arg2);
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_GetDomain(void * jarg1) {
78929   void * jresult ;
78930   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78931   Dali::Toolkit::RulerDomain *result = 0 ;
78932
78933   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78934   {
78935     try {
78936       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78937     } catch (std::out_of_range& e) {
78938       {
78939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78940       };
78941     } catch (std::exception& e) {
78942       {
78943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78944       };
78945     } catch (Dali::DaliException e) {
78946       {
78947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78948       };
78949     } catch (...) {
78950       {
78951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78952       };
78953     }
78954   }
78955
78956   jresult = (void *)result;
78957   return jresult;
78958 }
78959
78960
78961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78962   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78963
78964   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78965   {
78966     try {
78967       (arg1)->DisableDomain();
78968     } catch (std::out_of_range& e) {
78969       {
78970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78971       };
78972     } catch (std::exception& e) {
78973       {
78974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78975       };
78976     } catch (Dali::DaliException e) {
78977       {
78978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78979       };
78980     } catch (...) {
78981       {
78982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78983       };
78984     }
78985   }
78986
78987 }
78988
78989
78990 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78991   float jresult ;
78992   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78993   float arg2 ;
78994   float arg3 ;
78995   float arg4 ;
78996   float result;
78997
78998   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78999   arg2 = (float)jarg2;
79000   arg3 = (float)jarg3;
79001   arg4 = (float)jarg4;
79002   {
79003     try {
79004       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
79005     } catch (std::out_of_range& e) {
79006       {
79007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79008       };
79009     } catch (std::exception& e) {
79010       {
79011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79012       };
79013     } catch (Dali::DaliException e) {
79014       {
79015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79016       };
79017     } catch (...) {
79018       {
79019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79020       };
79021     }
79022   }
79023
79024   jresult = result;
79025   return jresult;
79026 }
79027
79028
79029 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
79030   float jresult ;
79031   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79032   float arg2 ;
79033   float arg3 ;
79034   float result;
79035
79036   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79037   arg2 = (float)jarg2;
79038   arg3 = (float)jarg3;
79039   {
79040     try {
79041       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
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_2(void * jarg1, float jarg2) {
79067   float jresult ;
79068   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79069   float arg2 ;
79070   float result;
79071
79072   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79073   arg2 = (float)jarg2;
79074   {
79075     try {
79076       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
79077     } catch (std::out_of_range& e) {
79078       {
79079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79080       };
79081     } catch (std::exception& e) {
79082       {
79083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79084       };
79085     } catch (Dali::DaliException e) {
79086       {
79087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79088       };
79089     } catch (...) {
79090       {
79091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79092       };
79093     }
79094   }
79095
79096   jresult = result;
79097   return jresult;
79098 }
79099
79100
79101 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
79102   float jresult ;
79103   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79104   float arg2 ;
79105   float arg3 ;
79106   float arg4 ;
79107   Dali::Toolkit::ClampState *arg5 = 0 ;
79108   float result;
79109
79110   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79111   arg2 = (float)jarg2;
79112   arg3 = (float)jarg3;
79113   arg4 = (float)jarg4;
79114   arg5 = (Dali::Toolkit::ClampState *)jarg5;
79115   if (!arg5) {
79116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79117     return 0;
79118   }
79119   {
79120     try {
79121       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
79122     } catch (std::out_of_range& e) {
79123       {
79124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79125       };
79126     } catch (std::exception& e) {
79127       {
79128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79129       };
79130     } catch (Dali::DaliException e) {
79131       {
79132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79133       };
79134     } catch (...) {
79135       {
79136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79137       };
79138     }
79139   }
79140
79141   jresult = result;
79142   return jresult;
79143 }
79144
79145
79146 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
79147   float jresult ;
79148   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79149   float arg2 ;
79150   float arg3 ;
79151   float arg4 ;
79152   float arg5 ;
79153   float result;
79154
79155   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79156   arg2 = (float)jarg2;
79157   arg3 = (float)jarg3;
79158   arg4 = (float)jarg4;
79159   arg5 = (float)jarg5;
79160   {
79161     try {
79162       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
79163     } catch (std::out_of_range& e) {
79164       {
79165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79166       };
79167     } catch (std::exception& e) {
79168       {
79169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79170       };
79171     } catch (Dali::DaliException e) {
79172       {
79173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79174       };
79175     } catch (...) {
79176       {
79177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79178       };
79179     }
79180   }
79181
79182   jresult = result;
79183   return jresult;
79184 }
79185
79186
79187 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
79188   float jresult ;
79189   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79190   float arg2 ;
79191   float arg3 ;
79192   float arg4 ;
79193   float result;
79194
79195   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79196   arg2 = (float)jarg2;
79197   arg3 = (float)jarg3;
79198   arg4 = (float)jarg4;
79199   {
79200     try {
79201       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
79202     } catch (std::out_of_range& e) {
79203       {
79204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79205       };
79206     } catch (std::exception& e) {
79207       {
79208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79209       };
79210     } catch (Dali::DaliException e) {
79211       {
79212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79213       };
79214     } catch (...) {
79215       {
79216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79217       };
79218     }
79219   }
79220
79221   jresult = result;
79222   return jresult;
79223 }
79224
79225
79226 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
79227   float jresult ;
79228   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79229   float arg2 ;
79230   float arg3 ;
79231   float result;
79232
79233   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79234   arg2 = (float)jarg2;
79235   arg3 = (float)jarg3;
79236   {
79237     try {
79238       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
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_3(void * jarg1, float jarg2) {
79264   float jresult ;
79265   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79266   float arg2 ;
79267   float result;
79268
79269   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79270   arg2 = (float)jarg2;
79271   {
79272     try {
79273       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
79274     } catch (std::out_of_range& e) {
79275       {
79276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79277       };
79278     } catch (std::exception& e) {
79279       {
79280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79281       };
79282     } catch (Dali::DaliException e) {
79283       {
79284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79285       };
79286     } catch (...) {
79287       {
79288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79289       };
79290     }
79291   }
79292
79293   jresult = result;
79294   return jresult;
79295 }
79296
79297
79298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
79299   float jresult ;
79300   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79301   float arg2 ;
79302   float arg3 ;
79303   float arg4 ;
79304   float arg5 ;
79305   Dali::Toolkit::ClampState *arg6 = 0 ;
79306   float result;
79307
79308   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79309   arg2 = (float)jarg2;
79310   arg3 = (float)jarg3;
79311   arg4 = (float)jarg4;
79312   arg5 = (float)jarg5;
79313   arg6 = (Dali::Toolkit::ClampState *)jarg6;
79314   if (!arg6) {
79315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79316     return 0;
79317   }
79318   {
79319     try {
79320       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
79321     } catch (std::out_of_range& e) {
79322       {
79323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79324       };
79325     } catch (std::exception& e) {
79326       {
79327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79328       };
79329     } catch (Dali::DaliException e) {
79330       {
79331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79332       };
79333     } catch (...) {
79334       {
79335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79336       };
79337     }
79338   }
79339
79340   jresult = result;
79341   return jresult;
79342 }
79343
79344
79345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
79346   void * jresult ;
79347   Dali::Toolkit::DefaultRuler *result = 0 ;
79348
79349   {
79350     try {
79351       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
79352     } catch (std::out_of_range& e) {
79353       {
79354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79355       };
79356     } catch (std::exception& e) {
79357       {
79358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79359       };
79360     } catch (Dali::DaliException e) {
79361       {
79362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79363       };
79364     } catch (...) {
79365       {
79366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79367       };
79368     }
79369   }
79370
79371   jresult = (void *)result;
79372   return jresult;
79373 }
79374
79375
79376 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79377   float jresult ;
79378   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79379   float arg2 ;
79380   float arg3 ;
79381   float result;
79382
79383   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79384   arg2 = (float)jarg2;
79385   arg3 = (float)jarg3;
79386   {
79387     try {
79388       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
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 = result;
79409   return jresult;
79410 }
79411
79412
79413 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79414   float jresult ;
79415   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79416   unsigned int arg2 ;
79417   unsigned int *arg3 = 0 ;
79418   bool arg4 ;
79419   float result;
79420
79421   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79422   arg2 = (unsigned int)jarg2;
79423   arg3 = (unsigned int *)jarg3;
79424   arg4 = jarg4 ? true : false;
79425   {
79426     try {
79427       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79428     } catch (std::out_of_range& e) {
79429       {
79430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79431       };
79432     } catch (std::exception& e) {
79433       {
79434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79435       };
79436     } catch (Dali::DaliException e) {
79437       {
79438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79439       };
79440     } catch (...) {
79441       {
79442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79443       };
79444     }
79445   }
79446
79447   jresult = result;
79448   return jresult;
79449 }
79450
79451
79452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79453   unsigned int jresult ;
79454   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79455   float arg2 ;
79456   bool arg3 ;
79457   unsigned int result;
79458
79459   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79460   arg2 = (float)jarg2;
79461   arg3 = jarg3 ? true : false;
79462   {
79463     try {
79464       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
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_GetTotalPages(void * jarg1) {
79490   unsigned int jresult ;
79491   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79492   unsigned int result;
79493
79494   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79495   {
79496     try {
79497       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
79498     } catch (std::out_of_range& e) {
79499       {
79500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79501       };
79502     } catch (std::exception& e) {
79503       {
79504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79505       };
79506     } catch (Dali::DaliException e) {
79507       {
79508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79509       };
79510     } catch (...) {
79511       {
79512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79513       };
79514     }
79515   }
79516
79517   jresult = result;
79518   return jresult;
79519 }
79520
79521
79522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79523   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79524
79525   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79526   {
79527     try {
79528       delete arg1;
79529     } catch (std::out_of_range& e) {
79530       {
79531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79532       };
79533     } catch (std::exception& e) {
79534       {
79535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79536       };
79537     } catch (Dali::DaliException e) {
79538       {
79539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79540       };
79541     } catch (...) {
79542       {
79543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79544       };
79545     }
79546   }
79547
79548 }
79549
79550
79551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79552   void * jresult ;
79553   float arg1 ;
79554   Dali::Toolkit::FixedRuler *result = 0 ;
79555
79556   arg1 = (float)jarg1;
79557   {
79558     try {
79559       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79560     } catch (std::out_of_range& e) {
79561       {
79562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79563       };
79564     } catch (std::exception& e) {
79565       {
79566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79567       };
79568     } catch (Dali::DaliException e) {
79569       {
79570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79571       };
79572     } catch (...) {
79573       {
79574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79575       };
79576     }
79577   }
79578
79579   jresult = (void *)result;
79580   return jresult;
79581 }
79582
79583
79584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79585   void * jresult ;
79586   Dali::Toolkit::FixedRuler *result = 0 ;
79587
79588   {
79589     try {
79590       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79591     } catch (std::out_of_range& e) {
79592       {
79593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79594       };
79595     } catch (std::exception& e) {
79596       {
79597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79598       };
79599     } catch (Dali::DaliException e) {
79600       {
79601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79602       };
79603     } catch (...) {
79604       {
79605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79606       };
79607     }
79608   }
79609
79610   jresult = (void *)result;
79611   return jresult;
79612 }
79613
79614
79615 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79616   float jresult ;
79617   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79618   float arg2 ;
79619   float arg3 ;
79620   float result;
79621
79622   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79623   arg2 = (float)jarg2;
79624   arg3 = (float)jarg3;
79625   {
79626     try {
79627       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
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 = result;
79648   return jresult;
79649 }
79650
79651
79652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79653   float jresult ;
79654   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79655   unsigned int arg2 ;
79656   unsigned int *arg3 = 0 ;
79657   bool arg4 ;
79658   float result;
79659
79660   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79661   arg2 = (unsigned int)jarg2;
79662   arg3 = (unsigned int *)jarg3;
79663   arg4 = jarg4 ? true : false;
79664   {
79665     try {
79666       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79667     } catch (std::out_of_range& e) {
79668       {
79669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79670       };
79671     } catch (std::exception& e) {
79672       {
79673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79674       };
79675     } catch (Dali::DaliException e) {
79676       {
79677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79678       };
79679     } catch (...) {
79680       {
79681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79682       };
79683     }
79684   }
79685
79686   jresult = result;
79687   return jresult;
79688 }
79689
79690
79691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79692   unsigned int jresult ;
79693   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79694   float arg2 ;
79695   bool arg3 ;
79696   unsigned int result;
79697
79698   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79699   arg2 = (float)jarg2;
79700   arg3 = jarg3 ? true : false;
79701   {
79702     try {
79703       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
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_GetTotalPages(void * jarg1) {
79729   unsigned int jresult ;
79730   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79731   unsigned int result;
79732
79733   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79734   {
79735     try {
79736       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79737     } catch (std::out_of_range& e) {
79738       {
79739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79740       };
79741     } catch (std::exception& e) {
79742       {
79743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79744       };
79745     } catch (Dali::DaliException e) {
79746       {
79747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79748       };
79749     } catch (...) {
79750       {
79751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79752       };
79753     }
79754   }
79755
79756   jresult = result;
79757   return jresult;
79758 }
79759
79760
79761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79762   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79763
79764   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79765   {
79766     try {
79767       delete arg1;
79768     } catch (std::out_of_range& e) {
79769       {
79770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79771       };
79772     } catch (std::exception& e) {
79773       {
79774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79775       };
79776     } catch (Dali::DaliException e) {
79777       {
79778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79779       };
79780     } catch (...) {
79781       {
79782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79783       };
79784     }
79785   }
79786
79787 }
79788
79789
79790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79791   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79792   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79793
79794   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79795   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79796   if (arg1) (arg1)->scale = *arg2;
79797 }
79798
79799
79800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79801   void * jresult ;
79802   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79803   Dali::Toolkit::ClampState2D *result = 0 ;
79804
79805   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79806   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79807   jresult = (void *)result;
79808   return jresult;
79809 }
79810
79811
79812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79813   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79814   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79815
79816   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79817   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79818   if (arg1) (arg1)->position = *arg2;
79819 }
79820
79821
79822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79823   void * jresult ;
79824   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79825   Dali::Toolkit::ClampState2D *result = 0 ;
79826
79827   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79828   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79829   jresult = (void *)result;
79830   return jresult;
79831 }
79832
79833
79834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79835   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79836   Dali::Toolkit::ClampState arg2 ;
79837
79838   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79839   arg2 = (Dali::Toolkit::ClampState)jarg2;
79840   if (arg1) (arg1)->rotation = arg2;
79841 }
79842
79843
79844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79845   int jresult ;
79846   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79847   Dali::Toolkit::ClampState result;
79848
79849   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79850   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79851   jresult = (int)result;
79852   return jresult;
79853 }
79854
79855
79856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79857   void * jresult ;
79858   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79859
79860   {
79861     try {
79862       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79863     } catch (std::out_of_range& e) {
79864       {
79865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79866       };
79867     } catch (std::exception& e) {
79868       {
79869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79870       };
79871     } catch (Dali::DaliException e) {
79872       {
79873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79874       };
79875     } catch (...) {
79876       {
79877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79878       };
79879     }
79880   }
79881
79882   jresult = (void *)result;
79883   return jresult;
79884 }
79885
79886
79887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79888   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79889
79890   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79891   {
79892     try {
79893       delete arg1;
79894     } catch (std::out_of_range& e) {
79895       {
79896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79897       };
79898     } catch (std::exception& e) {
79899       {
79900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79901       };
79902     } catch (Dali::DaliException e) {
79903       {
79904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79905       };
79906     } catch (...) {
79907       {
79908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79909       };
79910     }
79911   }
79912
79913 }
79914
79915
79916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79917   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79918   Dali::Toolkit::SnapType arg2 ;
79919
79920   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79921   arg2 = (Dali::Toolkit::SnapType)jarg2;
79922   if (arg1) (arg1)->type = arg2;
79923 }
79924
79925
79926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79927   int jresult ;
79928   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79929   Dali::Toolkit::SnapType result;
79930
79931   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79932   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79933   jresult = (int)result;
79934   return jresult;
79935 }
79936
79937
79938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79939   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79940   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79941
79942   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79943   arg2 = (Dali::Vector2 *)jarg2;
79944   if (arg1) (arg1)->position = *arg2;
79945 }
79946
79947
79948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79949   void * jresult ;
79950   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79951   Dali::Vector2 *result = 0 ;
79952
79953   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79954   result = (Dali::Vector2 *)& ((arg1)->position);
79955   jresult = (void *)result;
79956   return jresult;
79957 }
79958
79959
79960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79961   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79962   float arg2 ;
79963
79964   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79965   arg2 = (float)jarg2;
79966   if (arg1) (arg1)->duration = arg2;
79967 }
79968
79969
79970 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79971   float jresult ;
79972   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79973   float result;
79974
79975   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79976   result = (float) ((arg1)->duration);
79977   jresult = result;
79978   return jresult;
79979 }
79980
79981
79982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79983   void * jresult ;
79984   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79985
79986   {
79987     try {
79988       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79989     } catch (std::out_of_range& e) {
79990       {
79991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79992       };
79993     } catch (std::exception& e) {
79994       {
79995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79996       };
79997     } catch (Dali::DaliException e) {
79998       {
79999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80000       };
80001     } catch (...) {
80002       {
80003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80004       };
80005     }
80006   }
80007
80008   jresult = (void *)result;
80009   return jresult;
80010 }
80011
80012
80013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
80014   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
80015
80016   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
80017   {
80018     try {
80019       delete arg1;
80020     } catch (std::out_of_range& e) {
80021       {
80022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80023       };
80024     } catch (std::exception& e) {
80025       {
80026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80027       };
80028     } catch (Dali::DaliException e) {
80029       {
80030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80031       };
80032     } catch (...) {
80033       {
80034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80035       };
80036     }
80037   }
80038
80039 }
80040
80041
80042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
80043   int jresult ;
80044   int result;
80045
80046   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
80047   jresult = (int)result;
80048   return jresult;
80049 }
80050
80051
80052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
80053   int jresult ;
80054   int result;
80055
80056   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
80057   jresult = (int)result;
80058   return jresult;
80059 }
80060
80061
80062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
80063   int jresult ;
80064   int result;
80065
80066   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
80067   jresult = (int)result;
80068   return jresult;
80069 }
80070
80071
80072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
80073   int jresult ;
80074   int result;
80075
80076   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
80077   jresult = (int)result;
80078   return jresult;
80079 }
80080
80081
80082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
80083   int jresult ;
80084   int result;
80085
80086   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
80087   jresult = (int)result;
80088   return jresult;
80089 }
80090
80091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
80092   int jresult ;
80093   int result;
80094
80095   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
80096   jresult = (int)result;
80097   return jresult;
80098 }
80099
80100
80101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
80102   int jresult ;
80103   int result;
80104
80105   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
80106   jresult = (int)result;
80107   return jresult;
80108 }
80109
80110
80111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
80112   int jresult ;
80113   int result;
80114
80115   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
80116   jresult = (int)result;
80117   return jresult;
80118 }
80119
80120
80121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
80122   int jresult ;
80123   int result;
80124
80125   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
80126   jresult = (int)result;
80127   return jresult;
80128 }
80129
80130
80131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
80132   int jresult ;
80133   int result;
80134
80135   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
80136   jresult = (int)result;
80137   return jresult;
80138 }
80139
80140
80141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
80142   int jresult ;
80143   int result;
80144
80145   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
80146   jresult = (int)result;
80147   return jresult;
80148 }
80149
80150
80151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
80152   int jresult ;
80153   int result;
80154
80155   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
80156   jresult = (int)result;
80157   return jresult;
80158 }
80159
80160
80161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
80162   int jresult ;
80163   int result;
80164
80165   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
80166   jresult = (int)result;
80167   return jresult;
80168 }
80169
80170
80171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
80172   int jresult ;
80173   int result;
80174
80175   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
80176   jresult = (int)result;
80177   return jresult;
80178 }
80179
80180
80181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
80182   int jresult ;
80183   int result;
80184
80185   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
80186   jresult = (int)result;
80187   return jresult;
80188 }
80189
80190
80191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
80192   int jresult ;
80193   int result;
80194
80195   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
80196   jresult = (int)result;
80197   return jresult;
80198 }
80199
80200
80201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
80202   int jresult ;
80203   int result;
80204
80205   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
80206   jresult = (int)result;
80207   return jresult;
80208 }
80209
80210
80211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
80212   int jresult ;
80213   int result;
80214
80215   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
80216   jresult = (int)result;
80217   return jresult;
80218 }
80219
80220
80221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
80222   int jresult ;
80223   int result;
80224
80225   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
80226   jresult = (int)result;
80227   return jresult;
80228 }
80229
80230
80231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
80232   int jresult ;
80233   int result;
80234
80235   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
80236   jresult = (int)result;
80237   return jresult;
80238 }
80239
80240
80241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
80242   int jresult ;
80243   int result;
80244
80245   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
80246   jresult = (int)result;
80247   return jresult;
80248 }
80249
80250
80251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
80252   int jresult ;
80253   int result;
80254
80255   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
80256   jresult = (int)result;
80257   return jresult;
80258 }
80259
80260
80261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
80262   int jresult ;
80263   int result;
80264
80265   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
80266   jresult = (int)result;
80267   return jresult;
80268 }
80269
80270
80271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
80272   int jresult ;
80273   int result;
80274
80275   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
80276   jresult = (int)result;
80277   return jresult;
80278 }
80279
80280
80281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
80282   int jresult ;
80283   int result;
80284
80285   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
80286   jresult = (int)result;
80287   return jresult;
80288 }
80289
80290
80291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
80292   int jresult ;
80293   int result;
80294
80295   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
80296   jresult = (int)result;
80297   return jresult;
80298 }
80299
80300
80301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
80302   void * jresult ;
80303   Dali::Toolkit::ScrollView::Property *result = 0 ;
80304
80305   {
80306     try {
80307       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
80308     } catch (std::out_of_range& e) {
80309       {
80310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80311       };
80312     } catch (std::exception& e) {
80313       {
80314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80315       };
80316     } catch (Dali::DaliException e) {
80317       {
80318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80319       };
80320     } catch (...) {
80321       {
80322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80323       };
80324     }
80325   }
80326
80327   jresult = (void *)result;
80328   return jresult;
80329 }
80330
80331
80332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
80333   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
80334
80335   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
80336   {
80337     try {
80338       delete arg1;
80339     } catch (std::out_of_range& e) {
80340       {
80341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80342       };
80343     } catch (std::exception& e) {
80344       {
80345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80346       };
80347     } catch (Dali::DaliException e) {
80348       {
80349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80350       };
80351     } catch (...) {
80352       {
80353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80354       };
80355     }
80356   }
80357
80358 }
80359
80360
80361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
80362   void * jresult ;
80363   Dali::Toolkit::ScrollView *result = 0 ;
80364
80365   {
80366     try {
80367       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
80368     } catch (std::out_of_range& e) {
80369       {
80370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80371       };
80372     } catch (std::exception& e) {
80373       {
80374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80375       };
80376     } catch (Dali::DaliException e) {
80377       {
80378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80379       };
80380     } catch (...) {
80381       {
80382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80383       };
80384     }
80385   }
80386
80387   jresult = (void *)result;
80388   return jresult;
80389 }
80390
80391
80392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
80393   void * jresult ;
80394   Dali::Toolkit::ScrollView *arg1 = 0 ;
80395   Dali::Toolkit::ScrollView *result = 0 ;
80396
80397   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80398   if (!arg1) {
80399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80400     return 0;
80401   }
80402   {
80403     try {
80404       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
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_ScrollView_Assign(void * jarg1, void * jarg2) {
80430   void * jresult ;
80431   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80432   Dali::Toolkit::ScrollView *arg2 = 0 ;
80433   Dali::Toolkit::ScrollView *result = 0 ;
80434
80435   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80436   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
80437   if (!arg2) {
80438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80439     return 0;
80440   }
80441   {
80442     try {
80443       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
80444     } catch (std::out_of_range& e) {
80445       {
80446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80447       };
80448     } catch (std::exception& e) {
80449       {
80450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80451       };
80452     } catch (Dali::DaliException e) {
80453       {
80454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80455       };
80456     } catch (...) {
80457       {
80458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80459       };
80460     }
80461   }
80462
80463   jresult = (void *)result;
80464   return jresult;
80465 }
80466
80467
80468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
80469   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80470
80471   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80472   {
80473     try {
80474       delete arg1;
80475     } catch (std::out_of_range& e) {
80476       {
80477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80478       };
80479     } catch (std::exception& e) {
80480       {
80481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80482       };
80483     } catch (Dali::DaliException e) {
80484       {
80485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80486       };
80487     } catch (...) {
80488       {
80489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80490       };
80491     }
80492   }
80493
80494 }
80495
80496
80497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
80498   void * jresult ;
80499   Dali::Toolkit::ScrollView result;
80500
80501   {
80502     try {
80503       result = Dali::Toolkit::ScrollView::New();
80504     } catch (std::out_of_range& e) {
80505       {
80506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80507       };
80508     } catch (std::exception& e) {
80509       {
80510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80511       };
80512     } catch (Dali::DaliException e) {
80513       {
80514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80515       };
80516     } catch (...) {
80517       {
80518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80519       };
80520     }
80521   }
80522
80523   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80524   return jresult;
80525 }
80526
80527
80528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80529   void * jresult ;
80530   Dali::BaseHandle arg1 ;
80531   Dali::BaseHandle *argp1 ;
80532   Dali::Toolkit::ScrollView result;
80533
80534   argp1 = (Dali::BaseHandle *)jarg1;
80535   if (!argp1) {
80536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80537     return 0;
80538   }
80539   arg1 = *argp1;
80540   {
80541     try {
80542       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80543     } catch (std::out_of_range& e) {
80544       {
80545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80546       };
80547     } catch (std::exception& e) {
80548       {
80549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80550       };
80551     } catch (Dali::DaliException e) {
80552       {
80553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80554       };
80555     } catch (...) {
80556       {
80557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80558       };
80559     }
80560   }
80561
80562   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80563   return jresult;
80564 }
80565
80566
80567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80568   void * jresult ;
80569   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80570   Dali::AlphaFunction result;
80571
80572   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80573   {
80574     try {
80575       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80576     } catch (std::out_of_range& e) {
80577       {
80578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80579       };
80580     } catch (std::exception& e) {
80581       {
80582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80583       };
80584     } catch (Dali::DaliException e) {
80585       {
80586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80587       };
80588     } catch (...) {
80589       {
80590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80591       };
80592     }
80593   }
80594
80595   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80596   return jresult;
80597 }
80598
80599
80600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80601   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80602   Dali::AlphaFunction arg2 ;
80603   Dali::AlphaFunction *argp2 ;
80604
80605   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80606   argp2 = (Dali::AlphaFunction *)jarg2;
80607   if (!argp2) {
80608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80609     return ;
80610   }
80611   arg2 = *argp2;
80612   {
80613     try {
80614       (arg1)->SetScrollSnapAlphaFunction(arg2);
80615     } catch (std::out_of_range& e) {
80616       {
80617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80618       };
80619     } catch (std::exception& e) {
80620       {
80621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80622       };
80623     } catch (Dali::DaliException e) {
80624       {
80625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80626       };
80627     } catch (...) {
80628       {
80629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80630       };
80631     }
80632   }
80633
80634 }
80635
80636
80637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80638   void * jresult ;
80639   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80640   Dali::AlphaFunction result;
80641
80642   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80643   {
80644     try {
80645       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80646     } catch (std::out_of_range& e) {
80647       {
80648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80649       };
80650     } catch (std::exception& e) {
80651       {
80652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80653       };
80654     } catch (Dali::DaliException e) {
80655       {
80656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80657       };
80658     } catch (...) {
80659       {
80660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80661       };
80662     }
80663   }
80664
80665   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80666   return jresult;
80667 }
80668
80669
80670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80671   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80672   Dali::AlphaFunction arg2 ;
80673   Dali::AlphaFunction *argp2 ;
80674
80675   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80676   argp2 = (Dali::AlphaFunction *)jarg2;
80677   if (!argp2) {
80678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80679     return ;
80680   }
80681   arg2 = *argp2;
80682   {
80683     try {
80684       (arg1)->SetScrollFlickAlphaFunction(arg2);
80685     } catch (std::out_of_range& e) {
80686       {
80687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80688       };
80689     } catch (std::exception& e) {
80690       {
80691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80692       };
80693     } catch (Dali::DaliException e) {
80694       {
80695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80696       };
80697     } catch (...) {
80698       {
80699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80700       };
80701     }
80702   }
80703
80704 }
80705
80706
80707 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80708   float jresult ;
80709   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80710   float result;
80711
80712   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80713   {
80714     try {
80715       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80716     } catch (std::out_of_range& e) {
80717       {
80718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80719       };
80720     } catch (std::exception& e) {
80721       {
80722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80723       };
80724     } catch (Dali::DaliException e) {
80725       {
80726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80727       };
80728     } catch (...) {
80729       {
80730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80731       };
80732     }
80733   }
80734
80735   jresult = result;
80736   return jresult;
80737 }
80738
80739
80740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80741   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80742   float arg2 ;
80743
80744   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80745   arg2 = (float)jarg2;
80746   {
80747     try {
80748       (arg1)->SetScrollSnapDuration(arg2);
80749     } catch (std::out_of_range& e) {
80750       {
80751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80752       };
80753     } catch (std::exception& e) {
80754       {
80755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80756       };
80757     } catch (Dali::DaliException e) {
80758       {
80759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80760       };
80761     } catch (...) {
80762       {
80763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80764       };
80765     }
80766   }
80767
80768 }
80769
80770
80771 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80772   float jresult ;
80773   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80774   float result;
80775
80776   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80777   {
80778     try {
80779       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80780     } catch (std::out_of_range& e) {
80781       {
80782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80783       };
80784     } catch (std::exception& e) {
80785       {
80786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80787       };
80788     } catch (Dali::DaliException e) {
80789       {
80790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80791       };
80792     } catch (...) {
80793       {
80794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80795       };
80796     }
80797   }
80798
80799   jresult = result;
80800   return jresult;
80801 }
80802
80803
80804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80805   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80806   float arg2 ;
80807
80808   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80809   arg2 = (float)jarg2;
80810   {
80811     try {
80812       (arg1)->SetScrollFlickDuration(arg2);
80813     } catch (std::out_of_range& e) {
80814       {
80815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80816       };
80817     } catch (std::exception& e) {
80818       {
80819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80820       };
80821     } catch (Dali::DaliException e) {
80822       {
80823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80824       };
80825     } catch (...) {
80826       {
80827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80828       };
80829     }
80830   }
80831
80832 }
80833
80834
80835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80836   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80837   Dali::Toolkit::RulerPtr arg2 ;
80838   Dali::Toolkit::RulerPtr *argp2 ;
80839
80840   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80841   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80842   if (!argp2) {
80843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80844     return ;
80845   }
80846   arg2 = *argp2;
80847   {
80848     try {
80849       (arg1)->SetRulerX(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_SetRulerY(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)->SetRulerY(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_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80910   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80911   bool arg2 ;
80912
80913   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80914   arg2 = jarg2 ? true : false;
80915   {
80916     try {
80917       (arg1)->SetScrollSensitive(arg2);
80918     } catch (std::out_of_range& e) {
80919       {
80920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80921       };
80922     } catch (std::exception& e) {
80923       {
80924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80925       };
80926     } catch (Dali::DaliException e) {
80927       {
80928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80929       };
80930     } catch (...) {
80931       {
80932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80933       };
80934     }
80935   }
80936
80937 }
80938
80939
80940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80941   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80942   float arg2 ;
80943   float arg3 ;
80944
80945   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80946   arg2 = (float)jarg2;
80947   arg3 = (float)jarg3;
80948   {
80949     try {
80950       (arg1)->SetMaxOvershoot(arg2,arg3);
80951     } catch (std::out_of_range& e) {
80952       {
80953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80954       };
80955     } catch (std::exception& e) {
80956       {
80957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80958       };
80959     } catch (Dali::DaliException e) {
80960       {
80961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80962       };
80963     } catch (...) {
80964       {
80965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80966       };
80967     }
80968   }
80969
80970 }
80971
80972
80973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80974   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80975   Dali::AlphaFunction arg2 ;
80976   Dali::AlphaFunction *argp2 ;
80977
80978   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80979   argp2 = (Dali::AlphaFunction *)jarg2;
80980   if (!argp2) {
80981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80982     return ;
80983   }
80984   arg2 = *argp2;
80985   {
80986     try {
80987       (arg1)->SetSnapOvershootAlphaFunction(arg2);
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_SetSnapOvershootDuration(void * jarg1, float jarg2) {
81011   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81012   float arg2 ;
81013
81014   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81015   arg2 = (float)jarg2;
81016   {
81017     try {
81018       (arg1)->SetSnapOvershootDuration(arg2);
81019     } catch (std::out_of_range& e) {
81020       {
81021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81022       };
81023     } catch (std::exception& e) {
81024       {
81025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81026       };
81027     } catch (Dali::DaliException e) {
81028       {
81029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81030       };
81031     } catch (...) {
81032       {
81033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81034       };
81035     }
81036   }
81037
81038 }
81039
81040
81041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
81042   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81043   bool arg2 ;
81044
81045   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81046   arg2 = jarg2 ? true : false;
81047   {
81048     try {
81049       (arg1)->SetActorAutoSnap(arg2);
81050     } catch (std::out_of_range& e) {
81051       {
81052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81053       };
81054     } catch (std::exception& e) {
81055       {
81056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81057       };
81058     } catch (Dali::DaliException e) {
81059       {
81060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81061       };
81062     } catch (...) {
81063       {
81064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81065       };
81066     }
81067   }
81068
81069 }
81070
81071
81072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
81073   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81074   bool arg2 ;
81075
81076   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81077   arg2 = jarg2 ? true : false;
81078   {
81079     try {
81080       (arg1)->SetWrapMode(arg2);
81081     } catch (std::out_of_range& e) {
81082       {
81083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81084       };
81085     } catch (std::exception& e) {
81086       {
81087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81088       };
81089     } catch (Dali::DaliException e) {
81090       {
81091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81092       };
81093     } catch (...) {
81094       {
81095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81096       };
81097     }
81098   }
81099
81100 }
81101
81102
81103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
81104   int jresult ;
81105   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81106   int result;
81107
81108   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81109   {
81110     try {
81111       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
81112     } catch (std::out_of_range& e) {
81113       {
81114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81115       };
81116     } catch (std::exception& e) {
81117       {
81118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81119       };
81120     } catch (Dali::DaliException e) {
81121       {
81122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81123       };
81124     } catch (...) {
81125       {
81126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81127       };
81128     }
81129   }
81130
81131   jresult = result;
81132   return jresult;
81133 }
81134
81135
81136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
81137   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81138   int arg2 ;
81139
81140   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81141   arg2 = (int)jarg2;
81142   {
81143     try {
81144       (arg1)->SetScrollUpdateDistance(arg2);
81145     } catch (std::out_of_range& e) {
81146       {
81147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81148       };
81149     } catch (std::exception& e) {
81150       {
81151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81152       };
81153     } catch (Dali::DaliException e) {
81154       {
81155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81156       };
81157     } catch (...) {
81158       {
81159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81160       };
81161     }
81162   }
81163
81164 }
81165
81166
81167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
81168   unsigned int jresult ;
81169   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81170   bool result;
81171
81172   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81173   {
81174     try {
81175       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
81176     } catch (std::out_of_range& e) {
81177       {
81178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81179       };
81180     } catch (std::exception& e) {
81181       {
81182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81183       };
81184     } catch (Dali::DaliException e) {
81185       {
81186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81187       };
81188     } catch (...) {
81189       {
81190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81191       };
81192     }
81193   }
81194
81195   jresult = result;
81196   return jresult;
81197 }
81198
81199
81200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
81201   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81202   bool arg2 ;
81203
81204   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81205   arg2 = jarg2 ? true : false;
81206   {
81207     try {
81208       (arg1)->SetAxisAutoLock(arg2);
81209     } catch (std::out_of_range& e) {
81210       {
81211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81212       };
81213     } catch (std::exception& e) {
81214       {
81215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81216       };
81217     } catch (Dali::DaliException e) {
81218       {
81219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81220       };
81221     } catch (...) {
81222       {
81223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81224       };
81225     }
81226   }
81227
81228 }
81229
81230
81231 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
81232   float jresult ;
81233   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81234   float result;
81235
81236   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81237   {
81238     try {
81239       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
81240     } catch (std::out_of_range& e) {
81241       {
81242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81243       };
81244     } catch (std::exception& e) {
81245       {
81246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81247       };
81248     } catch (Dali::DaliException e) {
81249       {
81250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81251       };
81252     } catch (...) {
81253       {
81254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81255       };
81256     }
81257   }
81258
81259   jresult = result;
81260   return jresult;
81261 }
81262
81263
81264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
81265   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81266   float arg2 ;
81267
81268   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81269   arg2 = (float)jarg2;
81270   {
81271     try {
81272       (arg1)->SetAxisAutoLockGradient(arg2);
81273     } catch (std::out_of_range& e) {
81274       {
81275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81276       };
81277     } catch (std::exception& e) {
81278       {
81279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81280       };
81281     } catch (Dali::DaliException e) {
81282       {
81283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81284       };
81285     } catch (...) {
81286       {
81287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81288       };
81289     }
81290   }
81291
81292 }
81293
81294
81295 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
81296   float jresult ;
81297   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81298   float result;
81299
81300   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81301   {
81302     try {
81303       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
81304     } catch (std::out_of_range& e) {
81305       {
81306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81307       };
81308     } catch (std::exception& e) {
81309       {
81310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81311       };
81312     } catch (Dali::DaliException e) {
81313       {
81314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81315       };
81316     } catch (...) {
81317       {
81318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81319       };
81320     }
81321   }
81322
81323   jresult = result;
81324   return jresult;
81325 }
81326
81327
81328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
81329   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81330   float arg2 ;
81331
81332   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81333   arg2 = (float)jarg2;
81334   {
81335     try {
81336       (arg1)->SetFrictionCoefficient(arg2);
81337     } catch (std::out_of_range& e) {
81338       {
81339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81340       };
81341     } catch (std::exception& e) {
81342       {
81343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81344       };
81345     } catch (Dali::DaliException e) {
81346       {
81347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81348       };
81349     } catch (...) {
81350       {
81351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81352       };
81353     }
81354   }
81355
81356 }
81357
81358
81359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
81360   float jresult ;
81361   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81362   float result;
81363
81364   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81365   {
81366     try {
81367       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
81368     } catch (std::out_of_range& e) {
81369       {
81370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81371       };
81372     } catch (std::exception& e) {
81373       {
81374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81375       };
81376     } catch (Dali::DaliException e) {
81377       {
81378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81379       };
81380     } catch (...) {
81381       {
81382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81383       };
81384     }
81385   }
81386
81387   jresult = result;
81388   return jresult;
81389 }
81390
81391
81392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
81393   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81394   float arg2 ;
81395
81396   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81397   arg2 = (float)jarg2;
81398   {
81399     try {
81400       (arg1)->SetFlickSpeedCoefficient(arg2);
81401     } catch (std::out_of_range& e) {
81402       {
81403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81404       };
81405     } catch (std::exception& e) {
81406       {
81407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81408       };
81409     } catch (Dali::DaliException e) {
81410       {
81411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81412       };
81413     } catch (...) {
81414       {
81415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81416       };
81417     }
81418   }
81419
81420 }
81421
81422
81423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
81424   void * jresult ;
81425   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81426   Dali::Vector2 result;
81427
81428   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81429   {
81430     try {
81431       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
81432     } catch (std::out_of_range& e) {
81433       {
81434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81435       };
81436     } catch (std::exception& e) {
81437       {
81438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81439       };
81440     } catch (Dali::DaliException e) {
81441       {
81442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81443       };
81444     } catch (...) {
81445       {
81446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81447       };
81448     }
81449   }
81450
81451   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81452   return jresult;
81453 }
81454
81455
81456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
81457   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81458   Dali::Vector2 *arg2 = 0 ;
81459
81460   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81461   arg2 = (Dali::Vector2 *)jarg2;
81462   if (!arg2) {
81463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81464     return ;
81465   }
81466   {
81467     try {
81468       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
81469     } catch (std::out_of_range& e) {
81470       {
81471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81472       };
81473     } catch (std::exception& e) {
81474       {
81475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81476       };
81477     } catch (Dali::DaliException e) {
81478       {
81479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81480       };
81481     } catch (...) {
81482       {
81483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81484       };
81485     }
81486   }
81487
81488 }
81489
81490
81491 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
81492   float jresult ;
81493   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81494   float result;
81495
81496   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81497   {
81498     try {
81499       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
81500     } catch (std::out_of_range& e) {
81501       {
81502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81503       };
81504     } catch (std::exception& e) {
81505       {
81506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81507       };
81508     } catch (Dali::DaliException e) {
81509       {
81510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81511       };
81512     } catch (...) {
81513       {
81514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81515       };
81516     }
81517   }
81518
81519   jresult = result;
81520   return jresult;
81521 }
81522
81523
81524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
81525   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81526   float arg2 ;
81527
81528   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81529   arg2 = (float)jarg2;
81530   {
81531     try {
81532       (arg1)->SetMinimumSpeedForFlick(arg2);
81533     } catch (std::out_of_range& e) {
81534       {
81535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81536       };
81537     } catch (std::exception& e) {
81538       {
81539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81540       };
81541     } catch (Dali::DaliException e) {
81542       {
81543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81544       };
81545     } catch (...) {
81546       {
81547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81548       };
81549     }
81550   }
81551
81552 }
81553
81554
81555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81556   float jresult ;
81557   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81558   float result;
81559
81560   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81561   {
81562     try {
81563       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81564     } catch (std::out_of_range& e) {
81565       {
81566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81567       };
81568     } catch (std::exception& e) {
81569       {
81570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81571       };
81572     } catch (Dali::DaliException e) {
81573       {
81574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81575       };
81576     } catch (...) {
81577       {
81578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81579       };
81580     }
81581   }
81582
81583   jresult = result;
81584   return jresult;
81585 }
81586
81587
81588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81589   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81590   float arg2 ;
81591
81592   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81593   arg2 = (float)jarg2;
81594   {
81595     try {
81596       (arg1)->SetMaxFlickSpeed(arg2);
81597     } catch (std::out_of_range& e) {
81598       {
81599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81600       };
81601     } catch (std::exception& e) {
81602       {
81603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81604       };
81605     } catch (Dali::DaliException e) {
81606       {
81607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81608       };
81609     } catch (...) {
81610       {
81611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81612       };
81613     }
81614   }
81615
81616 }
81617
81618
81619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81620   void * jresult ;
81621   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81622   Dali::Vector2 result;
81623
81624   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81625   {
81626     try {
81627       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81628     } catch (std::out_of_range& e) {
81629       {
81630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81631       };
81632     } catch (std::exception& e) {
81633       {
81634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81635       };
81636     } catch (Dali::DaliException e) {
81637       {
81638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81639       };
81640     } catch (...) {
81641       {
81642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81643       };
81644     }
81645   }
81646
81647   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81648   return jresult;
81649 }
81650
81651
81652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81653   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81654   Dali::Vector2 arg2 ;
81655   Dali::Vector2 *argp2 ;
81656
81657   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81658   argp2 = (Dali::Vector2 *)jarg2;
81659   if (!argp2) {
81660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81661     return ;
81662   }
81663   arg2 = *argp2;
81664   {
81665     try {
81666       (arg1)->SetWheelScrollDistanceStep(arg2);
81667     } catch (std::out_of_range& e) {
81668       {
81669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81670       };
81671     } catch (std::exception& e) {
81672       {
81673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81674       };
81675     } catch (Dali::DaliException e) {
81676       {
81677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81678       };
81679     } catch (...) {
81680       {
81681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81682       };
81683     }
81684   }
81685
81686 }
81687
81688
81689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81690   void * jresult ;
81691   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81692   Dali::Vector2 result;
81693
81694   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81695   {
81696     try {
81697       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81698     } catch (std::out_of_range& e) {
81699       {
81700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81701       };
81702     } catch (std::exception& e) {
81703       {
81704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81705       };
81706     } catch (Dali::DaliException e) {
81707       {
81708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81709       };
81710     } catch (...) {
81711       {
81712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81713       };
81714     }
81715   }
81716
81717   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81718   return jresult;
81719 }
81720
81721
81722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81723   unsigned int jresult ;
81724   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81725   unsigned int result;
81726
81727   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81728   {
81729     try {
81730       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81731     } catch (std::out_of_range& e) {
81732       {
81733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81734       };
81735     } catch (std::exception& e) {
81736       {
81737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81738       };
81739     } catch (Dali::DaliException e) {
81740       {
81741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81742       };
81743     } catch (...) {
81744       {
81745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81746       };
81747     }
81748   }
81749
81750   jresult = result;
81751   return jresult;
81752 }
81753
81754
81755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81756   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81757   Dali::Vector2 *arg2 = 0 ;
81758
81759   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81760   arg2 = (Dali::Vector2 *)jarg2;
81761   if (!arg2) {
81762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81763     return ;
81764   }
81765   {
81766     try {
81767       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81768     } catch (std::out_of_range& e) {
81769       {
81770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81771       };
81772     } catch (std::exception& e) {
81773       {
81774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81775       };
81776     } catch (Dali::DaliException e) {
81777       {
81778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81779       };
81780     } catch (...) {
81781       {
81782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81783       };
81784     }
81785   }
81786
81787 }
81788
81789
81790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81791   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81792   Dali::Vector2 *arg2 = 0 ;
81793   float arg3 ;
81794
81795   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81796   arg2 = (Dali::Vector2 *)jarg2;
81797   if (!arg2) {
81798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81799     return ;
81800   }
81801   arg3 = (float)jarg3;
81802   {
81803     try {
81804       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
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_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81828   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81829   Dali::Vector2 *arg2 = 0 ;
81830   float arg3 ;
81831   Dali::AlphaFunction arg4 ;
81832   Dali::AlphaFunction *argp4 ;
81833
81834   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81835   arg2 = (Dali::Vector2 *)jarg2;
81836   if (!arg2) {
81837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81838     return ;
81839   }
81840   arg3 = (float)jarg3;
81841   argp4 = (Dali::AlphaFunction *)jarg4;
81842   if (!argp4) {
81843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81844     return ;
81845   }
81846   arg4 = *argp4;
81847   {
81848     try {
81849       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81850     } catch (std::out_of_range& e) {
81851       {
81852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81853       };
81854     } catch (std::exception& e) {
81855       {
81856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81857       };
81858     } catch (Dali::DaliException e) {
81859       {
81860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81861       };
81862     } catch (...) {
81863       {
81864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81865       };
81866     }
81867   }
81868
81869 }
81870
81871
81872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81873   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81874   Dali::Vector2 *arg2 = 0 ;
81875   float arg3 ;
81876   Dali::Toolkit::DirectionBias arg4 ;
81877   Dali::Toolkit::DirectionBias arg5 ;
81878
81879   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81880   arg2 = (Dali::Vector2 *)jarg2;
81881   if (!arg2) {
81882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81883     return ;
81884   }
81885   arg3 = (float)jarg3;
81886   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81887   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81888   {
81889     try {
81890       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81891     } catch (std::out_of_range& e) {
81892       {
81893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81894       };
81895     } catch (std::exception& e) {
81896       {
81897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81898       };
81899     } catch (Dali::DaliException e) {
81900       {
81901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81902       };
81903     } catch (...) {
81904       {
81905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81906       };
81907     }
81908   }
81909
81910 }
81911
81912
81913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81914   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81915   Dali::Vector2 *arg2 = 0 ;
81916   float arg3 ;
81917   Dali::AlphaFunction arg4 ;
81918   Dali::Toolkit::DirectionBias arg5 ;
81919   Dali::Toolkit::DirectionBias arg6 ;
81920   Dali::AlphaFunction *argp4 ;
81921
81922   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81923   arg2 = (Dali::Vector2 *)jarg2;
81924   if (!arg2) {
81925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81926     return ;
81927   }
81928   arg3 = (float)jarg3;
81929   argp4 = (Dali::AlphaFunction *)jarg4;
81930   if (!argp4) {
81931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81932     return ;
81933   }
81934   arg4 = *argp4;
81935   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81936   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81937   {
81938     try {
81939       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81940     } catch (std::out_of_range& e) {
81941       {
81942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81943       };
81944     } catch (std::exception& e) {
81945       {
81946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81947       };
81948     } catch (Dali::DaliException e) {
81949       {
81950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81951       };
81952     } catch (...) {
81953       {
81954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81955       };
81956     }
81957   }
81958
81959 }
81960
81961
81962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81963   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81964   unsigned int arg2 ;
81965
81966   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81967   arg2 = (unsigned int)jarg2;
81968   {
81969     try {
81970       (arg1)->ScrollTo(arg2);
81971     } catch (std::out_of_range& e) {
81972       {
81973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81974       };
81975     } catch (std::exception& e) {
81976       {
81977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81978       };
81979     } catch (Dali::DaliException e) {
81980       {
81981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81982       };
81983     } catch (...) {
81984       {
81985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81986       };
81987     }
81988   }
81989
81990 }
81991
81992
81993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81994   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81995   unsigned int arg2 ;
81996   float arg3 ;
81997
81998   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81999   arg2 = (unsigned int)jarg2;
82000   arg3 = (float)jarg3;
82001   {
82002     try {
82003       (arg1)->ScrollTo(arg2,arg3);
82004     } catch (std::out_of_range& e) {
82005       {
82006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82007       };
82008     } catch (std::exception& e) {
82009       {
82010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82011       };
82012     } catch (Dali::DaliException e) {
82013       {
82014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82015       };
82016     } catch (...) {
82017       {
82018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82019       };
82020     }
82021   }
82022
82023 }
82024
82025
82026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
82027   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82028   unsigned int arg2 ;
82029   float arg3 ;
82030   Dali::Toolkit::DirectionBias arg4 ;
82031
82032   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82033   arg2 = (unsigned int)jarg2;
82034   arg3 = (float)jarg3;
82035   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
82036   {
82037     try {
82038       (arg1)->ScrollTo(arg2,arg3,arg4);
82039     } catch (std::out_of_range& e) {
82040       {
82041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82042       };
82043     } catch (std::exception& e) {
82044       {
82045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82046       };
82047     } catch (Dali::DaliException e) {
82048       {
82049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82050       };
82051     } catch (...) {
82052       {
82053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82054       };
82055     }
82056   }
82057
82058 }
82059
82060
82061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
82062   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82063   Dali::Actor *arg2 = 0 ;
82064
82065   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82066   arg2 = (Dali::Actor *)jarg2;
82067   if (!arg2) {
82068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
82069     return ;
82070   }
82071   {
82072     try {
82073       (arg1)->ScrollTo(*arg2);
82074     } catch (std::out_of_range& e) {
82075       {
82076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82077       };
82078     } catch (std::exception& e) {
82079       {
82080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82081       };
82082     } catch (Dali::DaliException e) {
82083       {
82084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82085       };
82086     } catch (...) {
82087       {
82088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82089       };
82090     }
82091   }
82092
82093 }
82094
82095
82096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
82097   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82098   Dali::Actor *arg2 = 0 ;
82099   float arg3 ;
82100
82101   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82102   arg2 = (Dali::Actor *)jarg2;
82103   if (!arg2) {
82104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
82105     return ;
82106   }
82107   arg3 = (float)jarg3;
82108   {
82109     try {
82110       (arg1)->ScrollTo(*arg2,arg3);
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 unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
82134   unsigned int jresult ;
82135   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82136   bool result;
82137
82138   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82139   {
82140     try {
82141       result = (bool)(arg1)->ScrollToSnapPoint();
82142     } catch (std::out_of_range& e) {
82143       {
82144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82145       };
82146     } catch (std::exception& e) {
82147       {
82148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82149       };
82150     } catch (Dali::DaliException e) {
82151       {
82152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82153       };
82154     } catch (...) {
82155       {
82156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82157       };
82158     }
82159   }
82160
82161   jresult = result;
82162   return jresult;
82163 }
82164
82165
82166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
82167   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82168   Dali::Constraint arg2 ;
82169   Dali::Constraint *argp2 ;
82170
82171   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82172   argp2 = (Dali::Constraint *)jarg2;
82173   if (!argp2) {
82174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
82175     return ;
82176   }
82177   arg2 = *argp2;
82178   {
82179     try {
82180       (arg1)->ApplyConstraintToChildren(arg2);
82181     } catch (std::out_of_range& e) {
82182       {
82183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82184       };
82185     } catch (std::exception& e) {
82186       {
82187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82188       };
82189     } catch (Dali::DaliException e) {
82190       {
82191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82192       };
82193     } catch (...) {
82194       {
82195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82196       };
82197     }
82198   }
82199
82200 }
82201
82202
82203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
82204   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82205
82206   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82207   {
82208     try {
82209       (arg1)->RemoveConstraintsFromChildren();
82210     } catch (std::out_of_range& e) {
82211       {
82212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82213       };
82214     } catch (std::exception& e) {
82215       {
82216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82217       };
82218     } catch (Dali::DaliException e) {
82219       {
82220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82221       };
82222     } catch (...) {
82223       {
82224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82225       };
82226     }
82227   }
82228
82229 }
82230
82231
82232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
82233   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82234   Dali::Toolkit::ScrollViewEffect arg2 ;
82235   Dali::Toolkit::ScrollViewEffect *argp2 ;
82236
82237   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82238   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82239   if (!argp2) {
82240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82241     return ;
82242   }
82243   arg2 = *argp2;
82244   {
82245     try {
82246       (arg1)->ApplyEffect(arg2);
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_RemoveEffect(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)->RemoveEffect(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_RemoveAllEffects(void * jarg1) {
82307   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82308
82309   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82310   {
82311     try {
82312       (arg1)->RemoveAllEffects();
82313     } catch (std::out_of_range& e) {
82314       {
82315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82316       };
82317     } catch (std::exception& e) {
82318       {
82319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82320       };
82321     } catch (Dali::DaliException e) {
82322       {
82323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82324       };
82325     } catch (...) {
82326       {
82327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82328       };
82329     }
82330   }
82331
82332 }
82333
82334
82335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
82336   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82337   Dali::Actor arg2 ;
82338   Dali::Actor *argp2 ;
82339
82340   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82341   argp2 = (Dali::Actor *)jarg2;
82342   if (!argp2) {
82343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82344     return ;
82345   }
82346   arg2 = *argp2;
82347   {
82348     try {
82349       (arg1)->BindActor(arg2);
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_UnbindActor(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)->UnbindActor(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_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
82410   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82411   Dali::Radian arg2 ;
82412   Dali::Radian arg3 ;
82413   Dali::Radian *argp2 ;
82414   Dali::Radian *argp3 ;
82415
82416   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82417   argp2 = (Dali::Radian *)jarg2;
82418   if (!argp2) {
82419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82420     return ;
82421   }
82422   arg2 = *argp2;
82423   argp3 = (Dali::Radian *)jarg3;
82424   if (!argp3) {
82425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82426     return ;
82427   }
82428   arg3 = *argp3;
82429   {
82430     try {
82431       (arg1)->SetScrollingDirection(arg2,arg3);
82432     } catch (std::out_of_range& e) {
82433       {
82434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82435       };
82436     } catch (std::exception& e) {
82437       {
82438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82439       };
82440     } catch (Dali::DaliException e) {
82441       {
82442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82443       };
82444     } catch (...) {
82445       {
82446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82447       };
82448     }
82449   }
82450
82451 }
82452
82453
82454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
82455   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82456   Dali::Radian arg2 ;
82457   Dali::Radian *argp2 ;
82458
82459   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82460   argp2 = (Dali::Radian *)jarg2;
82461   if (!argp2) {
82462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82463     return ;
82464   }
82465   arg2 = *argp2;
82466   {
82467     try {
82468       (arg1)->SetScrollingDirection(arg2);
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_RemoveScrollingDirection(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)->RemoveScrollingDirection(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_SnapStartedSignal(void * jarg1) {
82529   void * jresult ;
82530   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82531   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82532
82533   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82534   {
82535     try {
82536       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82537     } catch (std::out_of_range& e) {
82538       {
82539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82540       };
82541     } catch (std::exception& e) {
82542       {
82543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82544       };
82545     } catch (Dali::DaliException e) {
82546       {
82547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82548       };
82549     } catch (...) {
82550       {
82551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82552       };
82553     }
82554   }
82555
82556   jresult = (void *)result;
82557   return jresult;
82558 }
82559
82560
82561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82562   int jresult ;
82563   int result;
82564
82565   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82566   jresult = (int)result;
82567   return jresult;
82568 }
82569
82570
82571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82572   int jresult ;
82573   int result;
82574
82575   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82576   jresult = (int)result;
82577   return jresult;
82578 }
82579
82580
82581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82582   int jresult ;
82583   int result;
82584
82585   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82586   jresult = (int)result;
82587   return jresult;
82588 }
82589
82590
82591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82592   int jresult ;
82593   int result;
82594
82595   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82596   jresult = (int)result;
82597   return jresult;
82598 }
82599
82600
82601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82602   int jresult ;
82603   int result;
82604
82605   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82606   jresult = (int)result;
82607   return jresult;
82608 }
82609
82610
82611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82612   void * jresult ;
82613   Dali::Toolkit::TableView::Property *result = 0 ;
82614
82615   {
82616     try {
82617       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82618     } catch (std::out_of_range& e) {
82619       {
82620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82621       };
82622     } catch (std::exception& e) {
82623       {
82624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82625       };
82626     } catch (Dali::DaliException e) {
82627       {
82628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82629       };
82630     } catch (...) {
82631       {
82632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82633       };
82634     }
82635   }
82636
82637   jresult = (void *)result;
82638   return jresult;
82639 }
82640
82641
82642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82643   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82644
82645   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82646   {
82647     try {
82648       delete arg1;
82649     } catch (std::out_of_range& e) {
82650       {
82651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82652       };
82653     } catch (std::exception& e) {
82654       {
82655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82656       };
82657     } catch (Dali::DaliException e) {
82658       {
82659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82660       };
82661     } catch (...) {
82662       {
82663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82664       };
82665     }
82666   }
82667
82668 }
82669
82670
82671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82672   int jresult ;
82673   int result;
82674
82675   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82676   jresult = (int)result;
82677   return jresult;
82678 }
82679
82680
82681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82682   int jresult ;
82683   int result;
82684
82685   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82686   jresult = (int)result;
82687   return jresult;
82688 }
82689
82690
82691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82692   int jresult ;
82693   int result;
82694
82695   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82696   jresult = (int)result;
82697   return jresult;
82698 }
82699
82700
82701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82702   int jresult ;
82703   int result;
82704
82705   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82706   jresult = (int)result;
82707   return jresult;
82708 }
82709
82710
82711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82712   int jresult ;
82713   int result;
82714
82715   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82716   jresult = (int)result;
82717   return jresult;
82718 }
82719
82720
82721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82722   void * jresult ;
82723   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82724
82725   {
82726     try {
82727       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82728     } catch (std::out_of_range& e) {
82729       {
82730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82731       };
82732     } catch (std::exception& e) {
82733       {
82734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82735       };
82736     } catch (Dali::DaliException e) {
82737       {
82738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82739       };
82740     } catch (...) {
82741       {
82742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82743       };
82744     }
82745   }
82746
82747   jresult = (void *)result;
82748   return jresult;
82749 }
82750
82751
82752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82753   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82754
82755   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82756   {
82757     try {
82758       delete arg1;
82759     } catch (std::out_of_range& e) {
82760       {
82761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82762       };
82763     } catch (std::exception& e) {
82764       {
82765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82766       };
82767     } catch (Dali::DaliException e) {
82768       {
82769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82770       };
82771     } catch (...) {
82772       {
82773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82774       };
82775     }
82776   }
82777
82778 }
82779
82780
82781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82782   void * jresult ;
82783   unsigned int arg1 ;
82784   unsigned int arg2 ;
82785   unsigned int arg3 ;
82786   unsigned int arg4 ;
82787   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82788
82789   arg1 = (unsigned int)jarg1;
82790   arg2 = (unsigned int)jarg2;
82791   arg3 = (unsigned int)jarg3;
82792   arg4 = (unsigned int)jarg4;
82793   {
82794     try {
82795       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82796     } catch (std::out_of_range& e) {
82797       {
82798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82799       };
82800     } catch (std::exception& e) {
82801       {
82802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82803       };
82804     } catch (Dali::DaliException e) {
82805       {
82806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82807       };
82808     } catch (...) {
82809       {
82810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82811       };
82812     }
82813   }
82814
82815   jresult = (void *)result;
82816   return jresult;
82817 }
82818
82819
82820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82821   void * jresult ;
82822   unsigned int arg1 ;
82823   unsigned int arg2 ;
82824   unsigned int arg3 ;
82825   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82826
82827   arg1 = (unsigned int)jarg1;
82828   arg2 = (unsigned int)jarg2;
82829   arg3 = (unsigned int)jarg3;
82830   {
82831     try {
82832       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
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_2(unsigned int jarg1, unsigned int jarg2) {
82858   void * jresult ;
82859   unsigned int arg1 ;
82860   unsigned int arg2 ;
82861   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82862
82863   arg1 = (unsigned int)jarg1;
82864   arg2 = (unsigned int)jarg2;
82865   {
82866     try {
82867       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82868     } catch (std::out_of_range& e) {
82869       {
82870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82871       };
82872     } catch (std::exception& e) {
82873       {
82874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82875       };
82876     } catch (Dali::DaliException e) {
82877       {
82878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82879       };
82880     } catch (...) {
82881       {
82882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82883       };
82884     }
82885   }
82886
82887   jresult = (void *)result;
82888   return jresult;
82889 }
82890
82891
82892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82893   void * jresult ;
82894   unsigned int arg1 ;
82895   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82896
82897   arg1 = (unsigned int)jarg1;
82898   {
82899     try {
82900       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82901     } catch (std::out_of_range& e) {
82902       {
82903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82904       };
82905     } catch (std::exception& e) {
82906       {
82907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82908       };
82909     } catch (Dali::DaliException e) {
82910       {
82911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82912       };
82913     } catch (...) {
82914       {
82915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82916       };
82917     }
82918   }
82919
82920   jresult = (void *)result;
82921   return jresult;
82922 }
82923
82924
82925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82926   void * jresult ;
82927   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82928
82929   {
82930     try {
82931       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82932     } catch (std::out_of_range& e) {
82933       {
82934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82935       };
82936     } catch (std::exception& e) {
82937       {
82938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82939       };
82940     } catch (Dali::DaliException e) {
82941       {
82942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82943       };
82944     } catch (...) {
82945       {
82946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82947       };
82948     }
82949   }
82950
82951   jresult = (void *)result;
82952   return jresult;
82953 }
82954
82955
82956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82957   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82958   unsigned int arg2 ;
82959
82960   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82961   arg2 = (unsigned int)jarg2;
82962   if (arg1) (arg1)->rowIndex = arg2;
82963 }
82964
82965
82966 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82967   unsigned int jresult ;
82968   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82969   unsigned int result;
82970
82971   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82972   result = (unsigned int) ((arg1)->rowIndex);
82973   jresult = result;
82974   return jresult;
82975 }
82976
82977
82978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82979   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82980   unsigned int arg2 ;
82981
82982   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82983   arg2 = (unsigned int)jarg2;
82984   if (arg1) (arg1)->columnIndex = arg2;
82985 }
82986
82987
82988 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82989   unsigned int jresult ;
82990   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82991   unsigned int result;
82992
82993   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82994   result = (unsigned int) ((arg1)->columnIndex);
82995   jresult = result;
82996   return jresult;
82997 }
82998
82999
83000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
83001   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83002   unsigned int arg2 ;
83003
83004   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83005   arg2 = (unsigned int)jarg2;
83006   if (arg1) (arg1)->rowSpan = arg2;
83007 }
83008
83009
83010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
83011   unsigned int jresult ;
83012   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83013   unsigned int result;
83014
83015   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83016   result = (unsigned int) ((arg1)->rowSpan);
83017   jresult = result;
83018   return jresult;
83019 }
83020
83021
83022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
83023   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83024   unsigned int arg2 ;
83025
83026   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83027   arg2 = (unsigned int)jarg2;
83028   if (arg1) (arg1)->columnSpan = arg2;
83029 }
83030
83031
83032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
83033   unsigned int jresult ;
83034   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83035   unsigned int result;
83036
83037   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83038   result = (unsigned int) ((arg1)->columnSpan);
83039   jresult = result;
83040   return jresult;
83041 }
83042
83043
83044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
83045   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83046
83047   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83048   {
83049     try {
83050       delete arg1;
83051     } catch (std::out_of_range& e) {
83052       {
83053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83054       };
83055     } catch (std::exception& e) {
83056       {
83057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83058       };
83059     } catch (Dali::DaliException e) {
83060       {
83061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83062       };
83063     } catch (...) {
83064       {
83065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83066       };
83067     }
83068   }
83069
83070 }
83071
83072
83073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
83074   void * jresult ;
83075   Dali::Toolkit::TableView *result = 0 ;
83076
83077   {
83078     try {
83079       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
83080     } catch (std::out_of_range& e) {
83081       {
83082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83083       };
83084     } catch (std::exception& e) {
83085       {
83086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83087       };
83088     } catch (Dali::DaliException e) {
83089       {
83090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83091       };
83092     } catch (...) {
83093       {
83094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83095       };
83096     }
83097   }
83098
83099   jresult = (void *)result;
83100   return jresult;
83101 }
83102
83103
83104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
83105   void * jresult ;
83106   Dali::Toolkit::TableView *arg1 = 0 ;
83107   Dali::Toolkit::TableView *result = 0 ;
83108
83109   arg1 = (Dali::Toolkit::TableView *)jarg1;
83110   if (!arg1) {
83111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83112     return 0;
83113   }
83114   {
83115     try {
83116       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
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_TableView_Assign(void * jarg1, void * jarg2) {
83142   void * jresult ;
83143   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83144   Dali::Toolkit::TableView *arg2 = 0 ;
83145   Dali::Toolkit::TableView *result = 0 ;
83146
83147   arg1 = (Dali::Toolkit::TableView *)jarg1;
83148   arg2 = (Dali::Toolkit::TableView *)jarg2;
83149   if (!arg2) {
83150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83151     return 0;
83152   }
83153   {
83154     try {
83155       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
83156     } catch (std::out_of_range& e) {
83157       {
83158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83159       };
83160     } catch (std::exception& e) {
83161       {
83162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83163       };
83164     } catch (Dali::DaliException e) {
83165       {
83166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83167       };
83168     } catch (...) {
83169       {
83170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83171       };
83172     }
83173   }
83174
83175   jresult = (void *)result;
83176   return jresult;
83177 }
83178
83179
83180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
83181   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83182
83183   arg1 = (Dali::Toolkit::TableView *)jarg1;
83184   {
83185     try {
83186       delete arg1;
83187     } catch (std::out_of_range& e) {
83188       {
83189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83190       };
83191     } catch (std::exception& e) {
83192       {
83193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83194       };
83195     } catch (Dali::DaliException e) {
83196       {
83197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83198       };
83199     } catch (...) {
83200       {
83201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83202       };
83203     }
83204   }
83205
83206 }
83207
83208
83209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
83210   void * jresult ;
83211   unsigned int arg1 ;
83212   unsigned int arg2 ;
83213   Dali::Toolkit::TableView result;
83214
83215   arg1 = (unsigned int)jarg1;
83216   arg2 = (unsigned int)jarg2;
83217   {
83218     try {
83219       result = Dali::Toolkit::TableView::New(arg1,arg2);
83220     } catch (std::out_of_range& e) {
83221       {
83222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83223       };
83224     } catch (std::exception& e) {
83225       {
83226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83227       };
83228     } catch (Dali::DaliException e) {
83229       {
83230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83231       };
83232     } catch (...) {
83233       {
83234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83235       };
83236     }
83237   }
83238
83239   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83240   return jresult;
83241 }
83242
83243
83244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
83245   void * jresult ;
83246   Dali::BaseHandle arg1 ;
83247   Dali::BaseHandle *argp1 ;
83248   Dali::Toolkit::TableView result;
83249
83250   argp1 = (Dali::BaseHandle *)jarg1;
83251   if (!argp1) {
83252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83253     return 0;
83254   }
83255   arg1 = *argp1;
83256   {
83257     try {
83258       result = Dali::Toolkit::TableView::DownCast(arg1);
83259     } catch (std::out_of_range& e) {
83260       {
83261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83262       };
83263     } catch (std::exception& e) {
83264       {
83265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83266       };
83267     } catch (Dali::DaliException e) {
83268       {
83269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83270       };
83271     } catch (...) {
83272       {
83273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83274       };
83275     }
83276   }
83277
83278   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83279   return jresult;
83280 }
83281
83282
83283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
83284   unsigned int jresult ;
83285   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83286   Dali::Actor arg2 ;
83287   Dali::Toolkit::TableView::CellPosition arg3 ;
83288   Dali::Actor *argp2 ;
83289   Dali::Toolkit::TableView::CellPosition *argp3 ;
83290   bool result;
83291
83292   arg1 = (Dali::Toolkit::TableView *)jarg1;
83293   argp2 = (Dali::Actor *)jarg2;
83294   if (!argp2) {
83295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83296     return 0;
83297   }
83298   arg2 = *argp2;
83299   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83300   if (!argp3) {
83301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83302     return 0;
83303   }
83304   arg3 = *argp3;
83305   {
83306     try {
83307       result = (bool)(arg1)->AddChild(arg2,arg3);
83308     } catch (std::out_of_range& e) {
83309       {
83310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83311       };
83312     } catch (std::exception& e) {
83313       {
83314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83315       };
83316     } catch (Dali::DaliException e) {
83317       {
83318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83319       };
83320     } catch (...) {
83321       {
83322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83323       };
83324     }
83325   }
83326
83327   jresult = result;
83328   return jresult;
83329 }
83330
83331
83332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
83333   void * jresult ;
83334   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83335   Dali::Toolkit::TableView::CellPosition arg2 ;
83336   Dali::Toolkit::TableView::CellPosition *argp2 ;
83337   Dali::Actor result;
83338
83339   arg1 = (Dali::Toolkit::TableView *)jarg1;
83340   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83341   if (!argp2) {
83342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83343     return 0;
83344   }
83345   arg2 = *argp2;
83346   {
83347     try {
83348       result = (arg1)->GetChildAt(arg2);
83349     } catch (std::out_of_range& e) {
83350       {
83351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83352       };
83353     } catch (std::exception& e) {
83354       {
83355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83356       };
83357     } catch (Dali::DaliException e) {
83358       {
83359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83360       };
83361     } catch (...) {
83362       {
83363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83364       };
83365     }
83366   }
83367
83368   jresult = new Dali::Actor((const Dali::Actor &)result);
83369   return jresult;
83370 }
83371
83372
83373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
83374   void * jresult ;
83375   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83376   Dali::Toolkit::TableView::CellPosition arg2 ;
83377   Dali::Toolkit::TableView::CellPosition *argp2 ;
83378   Dali::Actor result;
83379
83380   arg1 = (Dali::Toolkit::TableView *)jarg1;
83381   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83382   if (!argp2) {
83383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83384     return 0;
83385   }
83386   arg2 = *argp2;
83387   {
83388     try {
83389       result = (arg1)->RemoveChildAt(arg2);
83390     } catch (std::out_of_range& e) {
83391       {
83392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83393       };
83394     } catch (std::exception& e) {
83395       {
83396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83397       };
83398     } catch (Dali::DaliException e) {
83399       {
83400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83401       };
83402     } catch (...) {
83403       {
83404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83405       };
83406     }
83407   }
83408
83409   jresult = new Dali::Actor((const Dali::Actor &)result);
83410   return jresult;
83411 }
83412
83413
83414 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
83415   unsigned int jresult ;
83416   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83417   Dali::Actor arg2 ;
83418   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
83419   Dali::Actor *argp2 ;
83420   bool result;
83421
83422   arg1 = (Dali::Toolkit::TableView *)jarg1;
83423   argp2 = (Dali::Actor *)jarg2;
83424   if (!argp2) {
83425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83426     return 0;
83427   }
83428   arg2 = *argp2;
83429   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83430   if (!arg3) {
83431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
83432     return 0;
83433   }
83434   {
83435     try {
83436       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
83437     } catch (std::out_of_range& e) {
83438       {
83439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83440       };
83441     } catch (std::exception& e) {
83442       {
83443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83444       };
83445     } catch (Dali::DaliException e) {
83446       {
83447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83448       };
83449     } catch (...) {
83450       {
83451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83452       };
83453     }
83454   }
83455
83456   jresult = result;
83457   return jresult;
83458 }
83459
83460
83461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
83462   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83463   unsigned int arg2 ;
83464
83465   arg1 = (Dali::Toolkit::TableView *)jarg1;
83466   arg2 = (unsigned int)jarg2;
83467   {
83468     try {
83469       (arg1)->InsertRow(arg2);
83470     } catch (std::out_of_range& e) {
83471       {
83472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83473       };
83474     } catch (std::exception& e) {
83475       {
83476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83477       };
83478     } catch (Dali::DaliException e) {
83479       {
83480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83481       };
83482     } catch (...) {
83483       {
83484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83485       };
83486     }
83487   }
83488
83489 }
83490
83491
83492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
83493   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83494   unsigned int arg2 ;
83495
83496   arg1 = (Dali::Toolkit::TableView *)jarg1;
83497   arg2 = (unsigned int)jarg2;
83498   {
83499     try {
83500       (arg1)->DeleteRow(arg2);
83501     } catch (std::out_of_range& e) {
83502       {
83503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83504       };
83505     } catch (std::exception& e) {
83506       {
83507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83508       };
83509     } catch (Dali::DaliException e) {
83510       {
83511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83512       };
83513     } catch (...) {
83514       {
83515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83516       };
83517     }
83518   }
83519
83520 }
83521
83522
83523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83524   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83525   unsigned int arg2 ;
83526   std::vector< Dali::Actor > *arg3 = 0 ;
83527
83528   arg1 = (Dali::Toolkit::TableView *)jarg1;
83529   arg2 = (unsigned int)jarg2;
83530   arg3 = (std::vector< Dali::Actor > *)jarg3;
83531   if (!arg3) {
83532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83533     return ;
83534   }
83535   {
83536     try {
83537       (arg1)->DeleteRow(arg2,*arg3);
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_InsertColumn(void * jarg1, unsigned int jarg2) {
83561   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83562   unsigned int arg2 ;
83563
83564   arg1 = (Dali::Toolkit::TableView *)jarg1;
83565   arg2 = (unsigned int)jarg2;
83566   {
83567     try {
83568       (arg1)->InsertColumn(arg2);
83569     } catch (std::out_of_range& e) {
83570       {
83571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83572       };
83573     } catch (std::exception& e) {
83574       {
83575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83576       };
83577     } catch (Dali::DaliException e) {
83578       {
83579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83580       };
83581     } catch (...) {
83582       {
83583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83584       };
83585     }
83586   }
83587
83588 }
83589
83590
83591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83592   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83593   unsigned int arg2 ;
83594
83595   arg1 = (Dali::Toolkit::TableView *)jarg1;
83596   arg2 = (unsigned int)jarg2;
83597   {
83598     try {
83599       (arg1)->DeleteColumn(arg2);
83600     } catch (std::out_of_range& e) {
83601       {
83602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83603       };
83604     } catch (std::exception& e) {
83605       {
83606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83607       };
83608     } catch (Dali::DaliException e) {
83609       {
83610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83611       };
83612     } catch (...) {
83613       {
83614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83615       };
83616     }
83617   }
83618
83619 }
83620
83621
83622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83623   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83624   unsigned int arg2 ;
83625   std::vector< Dali::Actor > *arg3 = 0 ;
83626
83627   arg1 = (Dali::Toolkit::TableView *)jarg1;
83628   arg2 = (unsigned int)jarg2;
83629   arg3 = (std::vector< Dali::Actor > *)jarg3;
83630   if (!arg3) {
83631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83632     return ;
83633   }
83634   {
83635     try {
83636       (arg1)->DeleteColumn(arg2,*arg3);
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_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83660   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83661   unsigned int arg2 ;
83662   unsigned int arg3 ;
83663
83664   arg1 = (Dali::Toolkit::TableView *)jarg1;
83665   arg2 = (unsigned int)jarg2;
83666   arg3 = (unsigned int)jarg3;
83667   {
83668     try {
83669       (arg1)->Resize(arg2,arg3);
83670     } catch (std::out_of_range& e) {
83671       {
83672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83673       };
83674     } catch (std::exception& e) {
83675       {
83676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83677       };
83678     } catch (Dali::DaliException e) {
83679       {
83680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83681       };
83682     } catch (...) {
83683       {
83684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83685       };
83686     }
83687   }
83688
83689 }
83690
83691
83692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83693   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83694   unsigned int arg2 ;
83695   unsigned int arg3 ;
83696   std::vector< Dali::Actor > *arg4 = 0 ;
83697
83698   arg1 = (Dali::Toolkit::TableView *)jarg1;
83699   arg2 = (unsigned int)jarg2;
83700   arg3 = (unsigned int)jarg3;
83701   arg4 = (std::vector< Dali::Actor > *)jarg4;
83702   if (!arg4) {
83703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83704     return ;
83705   }
83706   {
83707     try {
83708       (arg1)->Resize(arg2,arg3,*arg4);
83709     } catch (std::out_of_range& e) {
83710       {
83711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83712       };
83713     } catch (std::exception& e) {
83714       {
83715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83716       };
83717     } catch (Dali::DaliException e) {
83718       {
83719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83720       };
83721     } catch (...) {
83722       {
83723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83724       };
83725     }
83726   }
83727
83728 }
83729
83730
83731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83732   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83733   Dali::Size arg2 ;
83734   Dali::Size *argp2 ;
83735
83736   arg1 = (Dali::Toolkit::TableView *)jarg1;
83737   argp2 = (Dali::Size *)jarg2;
83738   if (!argp2) {
83739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83740     return ;
83741   }
83742   arg2 = *argp2;
83743   {
83744     try {
83745       (arg1)->SetCellPadding(arg2);
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_GetCellPadding(void * jarg1) {
83769   void * jresult ;
83770   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83771   Dali::Size result;
83772
83773   arg1 = (Dali::Toolkit::TableView *)jarg1;
83774   {
83775     try {
83776       result = (arg1)->GetCellPadding();
83777     } catch (std::out_of_range& e) {
83778       {
83779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83780       };
83781     } catch (std::exception& e) {
83782       {
83783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83784       };
83785     } catch (Dali::DaliException e) {
83786       {
83787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83788       };
83789     } catch (...) {
83790       {
83791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83792       };
83793     }
83794   }
83795
83796   jresult = new Dali::Size((const Dali::Size &)result);
83797   return jresult;
83798 }
83799
83800
83801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83802   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83803   unsigned int arg2 ;
83804
83805   arg1 = (Dali::Toolkit::TableView *)jarg1;
83806   arg2 = (unsigned int)jarg2;
83807   {
83808     try {
83809       (arg1)->SetFitHeight(arg2);
83810     } catch (std::out_of_range& e) {
83811       {
83812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83813       };
83814     } catch (std::exception& e) {
83815       {
83816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83817       };
83818     } catch (Dali::DaliException e) {
83819       {
83820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83821       };
83822     } catch (...) {
83823       {
83824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83825       };
83826     }
83827   }
83828
83829 }
83830
83831
83832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83833   unsigned int jresult ;
83834   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83835   unsigned int arg2 ;
83836   bool result;
83837
83838   arg1 = (Dali::Toolkit::TableView *)jarg1;
83839   arg2 = (unsigned int)jarg2;
83840   {
83841     try {
83842       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83843     } catch (std::out_of_range& e) {
83844       {
83845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83846       };
83847     } catch (std::exception& e) {
83848       {
83849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83850       };
83851     } catch (Dali::DaliException e) {
83852       {
83853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83854       };
83855     } catch (...) {
83856       {
83857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83858       };
83859     }
83860   }
83861
83862   jresult = result;
83863   return jresult;
83864 }
83865
83866
83867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83868   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83869   unsigned int arg2 ;
83870
83871   arg1 = (Dali::Toolkit::TableView *)jarg1;
83872   arg2 = (unsigned int)jarg2;
83873   {
83874     try {
83875       (arg1)->SetFitWidth(arg2);
83876     } catch (std::out_of_range& e) {
83877       {
83878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83879       };
83880     } catch (std::exception& e) {
83881       {
83882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83883       };
83884     } catch (Dali::DaliException e) {
83885       {
83886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83887       };
83888     } catch (...) {
83889       {
83890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83891       };
83892     }
83893   }
83894
83895 }
83896
83897
83898 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83899   unsigned int jresult ;
83900   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83901   unsigned int arg2 ;
83902   bool result;
83903
83904   arg1 = (Dali::Toolkit::TableView *)jarg1;
83905   arg2 = (unsigned int)jarg2;
83906   {
83907     try {
83908       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83909     } catch (std::out_of_range& e) {
83910       {
83911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83912       };
83913     } catch (std::exception& e) {
83914       {
83915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83916       };
83917     } catch (Dali::DaliException e) {
83918       {
83919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83920       };
83921     } catch (...) {
83922       {
83923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83924       };
83925     }
83926   }
83927
83928   jresult = result;
83929   return jresult;
83930 }
83931
83932
83933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83934   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83935   unsigned int arg2 ;
83936   float arg3 ;
83937
83938   arg1 = (Dali::Toolkit::TableView *)jarg1;
83939   arg2 = (unsigned int)jarg2;
83940   arg3 = (float)jarg3;
83941   {
83942     try {
83943       (arg1)->SetFixedHeight(arg2,arg3);
83944     } catch (std::out_of_range& e) {
83945       {
83946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83947       };
83948     } catch (std::exception& e) {
83949       {
83950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83951       };
83952     } catch (Dali::DaliException e) {
83953       {
83954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83955       };
83956     } catch (...) {
83957       {
83958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83959       };
83960     }
83961   }
83962
83963 }
83964
83965
83966 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83967   float jresult ;
83968   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83969   unsigned int arg2 ;
83970   float result;
83971
83972   arg1 = (Dali::Toolkit::TableView *)jarg1;
83973   arg2 = (unsigned int)jarg2;
83974   {
83975     try {
83976       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83977     } catch (std::out_of_range& e) {
83978       {
83979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83980       };
83981     } catch (std::exception& e) {
83982       {
83983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83984       };
83985     } catch (Dali::DaliException e) {
83986       {
83987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83988       };
83989     } catch (...) {
83990       {
83991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83992       };
83993     }
83994   }
83995
83996   jresult = result;
83997   return jresult;
83998 }
83999
84000
84001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
84002   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84003   unsigned int arg2 ;
84004   float arg3 ;
84005
84006   arg1 = (Dali::Toolkit::TableView *)jarg1;
84007   arg2 = (unsigned int)jarg2;
84008   arg3 = (float)jarg3;
84009   {
84010     try {
84011       (arg1)->SetRelativeHeight(arg2,arg3);
84012     } catch (std::out_of_range& e) {
84013       {
84014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84015       };
84016     } catch (std::exception& e) {
84017       {
84018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84019       };
84020     } catch (Dali::DaliException e) {
84021       {
84022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84023       };
84024     } catch (...) {
84025       {
84026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84027       };
84028     }
84029   }
84030
84031 }
84032
84033
84034 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
84035   float jresult ;
84036   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84037   unsigned int arg2 ;
84038   float result;
84039
84040   arg1 = (Dali::Toolkit::TableView *)jarg1;
84041   arg2 = (unsigned int)jarg2;
84042   {
84043     try {
84044       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
84045     } catch (std::out_of_range& e) {
84046       {
84047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84048       };
84049     } catch (std::exception& e) {
84050       {
84051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84052       };
84053     } catch (Dali::DaliException e) {
84054       {
84055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84056       };
84057     } catch (...) {
84058       {
84059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84060       };
84061     }
84062   }
84063
84064   jresult = result;
84065   return jresult;
84066 }
84067
84068
84069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84070   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84071   unsigned int arg2 ;
84072   float arg3 ;
84073
84074   arg1 = (Dali::Toolkit::TableView *)jarg1;
84075   arg2 = (unsigned int)jarg2;
84076   arg3 = (float)jarg3;
84077   {
84078     try {
84079       (arg1)->SetFixedWidth(arg2,arg3);
84080     } catch (std::out_of_range& e) {
84081       {
84082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84083       };
84084     } catch (std::exception& e) {
84085       {
84086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84087       };
84088     } catch (Dali::DaliException e) {
84089       {
84090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84091       };
84092     } catch (...) {
84093       {
84094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84095       };
84096     }
84097   }
84098
84099 }
84100
84101
84102 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
84103   float jresult ;
84104   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84105   unsigned int arg2 ;
84106   float result;
84107
84108   arg1 = (Dali::Toolkit::TableView *)jarg1;
84109   arg2 = (unsigned int)jarg2;
84110   {
84111     try {
84112       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
84113     } catch (std::out_of_range& e) {
84114       {
84115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84116       };
84117     } catch (std::exception& e) {
84118       {
84119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84120       };
84121     } catch (Dali::DaliException e) {
84122       {
84123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84124       };
84125     } catch (...) {
84126       {
84127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84128       };
84129     }
84130   }
84131
84132   jresult = result;
84133   return jresult;
84134 }
84135
84136
84137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84138   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84139   unsigned int arg2 ;
84140   float arg3 ;
84141
84142   arg1 = (Dali::Toolkit::TableView *)jarg1;
84143   arg2 = (unsigned int)jarg2;
84144   arg3 = (float)jarg3;
84145   {
84146     try {
84147       (arg1)->SetRelativeWidth(arg2,arg3);
84148     } catch (std::out_of_range& e) {
84149       {
84150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84151       };
84152     } catch (std::exception& e) {
84153       {
84154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84155       };
84156     } catch (Dali::DaliException e) {
84157       {
84158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84159       };
84160     } catch (...) {
84161       {
84162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84163       };
84164     }
84165   }
84166
84167 }
84168
84169
84170 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
84171   float jresult ;
84172   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84173   unsigned int arg2 ;
84174   float result;
84175
84176   arg1 = (Dali::Toolkit::TableView *)jarg1;
84177   arg2 = (unsigned int)jarg2;
84178   {
84179     try {
84180       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
84181     } catch (std::out_of_range& e) {
84182       {
84183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84184       };
84185     } catch (std::exception& e) {
84186       {
84187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84188       };
84189     } catch (Dali::DaliException e) {
84190       {
84191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84192       };
84193     } catch (...) {
84194       {
84195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84196       };
84197     }
84198   }
84199
84200   jresult = result;
84201   return jresult;
84202 }
84203
84204
84205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
84206   unsigned int jresult ;
84207   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84208   unsigned int result;
84209
84210   arg1 = (Dali::Toolkit::TableView *)jarg1;
84211   {
84212     try {
84213       result = (unsigned int)(arg1)->GetRows();
84214     } catch (std::out_of_range& e) {
84215       {
84216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84217       };
84218     } catch (std::exception& e) {
84219       {
84220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84221       };
84222     } catch (Dali::DaliException e) {
84223       {
84224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84225       };
84226     } catch (...) {
84227       {
84228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84229       };
84230     }
84231   }
84232
84233   jresult = result;
84234   return jresult;
84235 }
84236
84237
84238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
84239   unsigned int jresult ;
84240   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84241   unsigned int result;
84242
84243   arg1 = (Dali::Toolkit::TableView *)jarg1;
84244   {
84245     try {
84246       result = (unsigned int)(arg1)->GetColumns();
84247     } catch (std::out_of_range& e) {
84248       {
84249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84250       };
84251     } catch (std::exception& e) {
84252       {
84253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84254       };
84255     } catch (Dali::DaliException e) {
84256       {
84257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84258       };
84259     } catch (...) {
84260       {
84261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84262       };
84263     }
84264   }
84265
84266   jresult = result;
84267   return jresult;
84268 }
84269
84270
84271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
84272   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84273   Dali::Toolkit::TableView::CellPosition arg2 ;
84274   Dali::HorizontalAlignment::Type arg3 ;
84275   Dali::VerticalAlignment::Type arg4 ;
84276   Dali::Toolkit::TableView::CellPosition *argp2 ;
84277
84278   arg1 = (Dali::Toolkit::TableView *)jarg1;
84279   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
84280   if (!argp2) {
84281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
84282     return ;
84283   }
84284   arg2 = *argp2;
84285   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
84286   arg4 = (Dali::VerticalAlignment::Type)jarg4;
84287   {
84288     try {
84289       (arg1)->SetCellAlignment(arg2,arg3,arg4);
84290     } catch (std::out_of_range& e) {
84291       {
84292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84293       };
84294     } catch (std::exception& e) {
84295       {
84296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84297       };
84298     } catch (Dali::DaliException e) {
84299       {
84300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84301       };
84302     } catch (...) {
84303       {
84304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84305       };
84306     }
84307   }
84308
84309 }
84310
84311
84312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
84313   unsigned int jresult ;
84314   unsigned int result;
84315
84316   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
84317   jresult = result;
84318   return jresult;
84319 }
84320
84321
84322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
84323   int jresult ;
84324   int result;
84325
84326   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
84327   jresult = (int)result;
84328   return jresult;
84329 }
84330
84331
84332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
84333   int jresult ;
84334   int result;
84335
84336   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
84337   jresult = (int)result;
84338   return jresult;
84339 }
84340
84341
84342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
84343   int jresult ;
84344   int result;
84345
84346   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
84347   jresult = (int)result;
84348   return jresult;
84349 }
84350
84351
84352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
84353   int jresult ;
84354   int result;
84355
84356   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
84357   jresult = (int)result;
84358   return jresult;
84359 }
84360
84361
84362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
84363   int jresult ;
84364   int result;
84365
84366   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
84367   jresult = (int)result;
84368   return jresult;
84369 }
84370
84371
84372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
84373   int jresult ;
84374   int result;
84375
84376   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
84377   jresult = (int)result;
84378   return jresult;
84379 }
84380
84381
84382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
84383   int jresult ;
84384   int result;
84385
84386   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
84387   jresult = (int)result;
84388   return jresult;
84389 }
84390
84391
84392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
84393   int jresult ;
84394   int result;
84395
84396   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
84397   jresult = (int)result;
84398   return jresult;
84399 }
84400
84401
84402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
84403   int jresult ;
84404   int result;
84405
84406   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
84407   jresult = (int)result;
84408   return jresult;
84409 }
84410
84411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
84412   int jresult ;
84413   int result;
84414
84415   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
84416   jresult = (int)result;
84417   return jresult;
84418 }
84419
84420
84421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
84422   int jresult ;
84423   int result;
84424
84425   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
84426   jresult = (int)result;
84427   return jresult;
84428 }
84429
84430
84431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
84432   int jresult ;
84433   int result;
84434
84435   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
84436   jresult = (int)result;
84437   return jresult;
84438 }
84439
84440
84441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
84442   int jresult ;
84443   int result;
84444
84445   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
84446   jresult = (int)result;
84447   return jresult;
84448 }
84449
84450
84451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
84452   int jresult ;
84453   int result;
84454
84455   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
84456   jresult = (int)result;
84457   return jresult;
84458 }
84459
84460
84461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
84462   int jresult ;
84463   int result;
84464
84465   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
84466   jresult = (int)result;
84467   return jresult;
84468 }
84469
84470
84471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
84472   int jresult ;
84473   int result;
84474
84475   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
84476   jresult = (int)result;
84477   return jresult;
84478 }
84479
84480
84481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
84482   int jresult ;
84483   int result;
84484
84485   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
84486   jresult = (int)result;
84487   return jresult;
84488 }
84489
84490
84491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
84492   int jresult ;
84493   int result;
84494
84495   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
84496   jresult = (int)result;
84497   return jresult;
84498 }
84499
84500
84501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
84502   int jresult ;
84503   int result;
84504
84505   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
84506   jresult = (int)result;
84507   return jresult;
84508 }
84509
84510
84511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
84512   int jresult ;
84513   int result;
84514
84515   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
84516   jresult = (int)result;
84517   return jresult;
84518 }
84519
84520
84521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
84522   int jresult ;
84523   int result;
84524
84525   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
84526   jresult = (int)result;
84527   return jresult;
84528 }
84529
84530
84531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
84532   int jresult ;
84533   int result;
84534
84535   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
84536   jresult = (int)result;
84537   return jresult;
84538 }
84539
84540
84541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
84542   int jresult ;
84543   int result;
84544
84545   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
84546   jresult = (int)result;
84547   return jresult;
84548 }
84549
84550
84551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84552   int jresult ;
84553   int result;
84554
84555   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84556   jresult = (int)result;
84557   return jresult;
84558 }
84559
84560
84561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84562   void * jresult ;
84563   Dali::Toolkit::TextLabel::Property *result = 0 ;
84564
84565   {
84566     try {
84567       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84568     } catch (std::out_of_range& e) {
84569       {
84570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84571       };
84572     } catch (std::exception& e) {
84573       {
84574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84575       };
84576     } catch (Dali::DaliException e) {
84577       {
84578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84579       };
84580     } catch (...) {
84581       {
84582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84583       };
84584     }
84585   }
84586
84587   jresult = (void *)result;
84588   return jresult;
84589 }
84590
84591
84592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84593   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84594
84595   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84596   {
84597     try {
84598       delete arg1;
84599     } catch (std::out_of_range& e) {
84600       {
84601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84602       };
84603     } catch (std::exception& e) {
84604       {
84605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84606       };
84607     } catch (Dali::DaliException e) {
84608       {
84609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84610       };
84611     } catch (...) {
84612       {
84613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84614       };
84615     }
84616   }
84617
84618 }
84619
84620
84621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84622   void * jresult ;
84623   Dali::Toolkit::TextLabel result;
84624
84625   {
84626     try {
84627       result = Dali::Toolkit::TextLabel::New();
84628     } catch (std::out_of_range& e) {
84629       {
84630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84631       };
84632     } catch (std::exception& e) {
84633       {
84634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84635       };
84636     } catch (Dali::DaliException e) {
84637       {
84638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84639       };
84640     } catch (...) {
84641       {
84642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84643       };
84644     }
84645   }
84646
84647   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84648   return jresult;
84649 }
84650
84651
84652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84653   void * jresult ;
84654   std::string *arg1 = 0 ;
84655   Dali::Toolkit::TextLabel result;
84656
84657   if (!jarg1) {
84658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84659     return 0;
84660   }
84661   std::string arg1_str(jarg1);
84662   arg1 = &arg1_str;
84663   {
84664     try {
84665       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84666     } catch (std::out_of_range& e) {
84667       {
84668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84669       };
84670     } catch (std::exception& e) {
84671       {
84672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84673       };
84674     } catch (Dali::DaliException e) {
84675       {
84676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84677       };
84678     } catch (...) {
84679       {
84680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84681       };
84682     }
84683   }
84684
84685   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84686
84687   //argout typemap for const std::string&
84688
84689   return jresult;
84690 }
84691
84692
84693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84694   void * jresult ;
84695   Dali::Toolkit::TextLabel *result = 0 ;
84696
84697   {
84698     try {
84699       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84700     } catch (std::out_of_range& e) {
84701       {
84702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84703       };
84704     } catch (std::exception& e) {
84705       {
84706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84707       };
84708     } catch (Dali::DaliException e) {
84709       {
84710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84711       };
84712     } catch (...) {
84713       {
84714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84715       };
84716     }
84717   }
84718
84719   jresult = (void *)result;
84720   return jresult;
84721 }
84722
84723
84724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84725   void * jresult ;
84726   Dali::Toolkit::TextLabel *arg1 = 0 ;
84727   Dali::Toolkit::TextLabel *result = 0 ;
84728
84729   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84730   if (!arg1) {
84731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84732     return 0;
84733   }
84734   {
84735     try {
84736       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
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_TextLabel_Assign(void * jarg1, void * jarg2) {
84762   void * jresult ;
84763   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84764   Dali::Toolkit::TextLabel *arg2 = 0 ;
84765   Dali::Toolkit::TextLabel *result = 0 ;
84766
84767   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84768   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84769   if (!arg2) {
84770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84771     return 0;
84772   }
84773   {
84774     try {
84775       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84776     } catch (std::out_of_range& e) {
84777       {
84778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84779       };
84780     } catch (std::exception& e) {
84781       {
84782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84783       };
84784     } catch (Dali::DaliException e) {
84785       {
84786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84787       };
84788     } catch (...) {
84789       {
84790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84791       };
84792     }
84793   }
84794
84795   jresult = (void *)result;
84796   return jresult;
84797 }
84798
84799
84800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84801   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84802
84803   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84804   {
84805     try {
84806       delete arg1;
84807     } catch (std::out_of_range& e) {
84808       {
84809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84810       };
84811     } catch (std::exception& e) {
84812       {
84813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84814       };
84815     } catch (Dali::DaliException e) {
84816       {
84817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84818       };
84819     } catch (...) {
84820       {
84821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84822       };
84823     }
84824   }
84825
84826 }
84827
84828
84829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84830   void * jresult ;
84831   Dali::BaseHandle arg1 ;
84832   Dali::BaseHandle *argp1 ;
84833   Dali::Toolkit::TextLabel result;
84834
84835   argp1 = (Dali::BaseHandle *)jarg1;
84836   if (!argp1) {
84837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84838     return 0;
84839   }
84840   arg1 = *argp1;
84841   {
84842     try {
84843       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84844     } catch (std::out_of_range& e) {
84845       {
84846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84847       };
84848     } catch (std::exception& e) {
84849       {
84850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84851       };
84852     } catch (Dali::DaliException e) {
84853       {
84854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84855       };
84856     } catch (...) {
84857       {
84858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84859       };
84860     }
84861   }
84862
84863   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84864   return jresult;
84865 }
84866
84867
84868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84869   void * jresult ;
84870   Dali::Toolkit::AccessibilityManager *result = 0 ;
84871
84872   {
84873     try {
84874       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84875     } catch (std::out_of_range& e) {
84876       {
84877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84878       };
84879     } catch (std::exception& e) {
84880       {
84881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84882       };
84883     } catch (Dali::DaliException e) {
84884       {
84885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84886       };
84887     } catch (...) {
84888       {
84889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84890       };
84891     }
84892   }
84893
84894   jresult = (void *)result;
84895   return jresult;
84896 }
84897
84898
84899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84900   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84901
84902   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84903   {
84904     try {
84905       delete arg1;
84906     } catch (std::out_of_range& e) {
84907       {
84908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84909       };
84910     } catch (std::exception& e) {
84911       {
84912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84913       };
84914     } catch (Dali::DaliException e) {
84915       {
84916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84917       };
84918     } catch (...) {
84919       {
84920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84921       };
84922     }
84923   }
84924
84925 }
84926
84927
84928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84929   void * jresult ;
84930   Dali::Toolkit::AccessibilityManager result;
84931
84932   {
84933     try {
84934       result = Dali::Toolkit::AccessibilityManager::Get();
84935     } catch (std::out_of_range& e) {
84936       {
84937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84938       };
84939     } catch (std::exception& e) {
84940       {
84941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84942       };
84943     } catch (Dali::DaliException e) {
84944       {
84945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84946       };
84947     } catch (...) {
84948       {
84949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84950       };
84951     }
84952   }
84953
84954   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84955   return jresult;
84956 }
84957
84958
84959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84960   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84961   Dali::Actor arg2 ;
84962   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84963   std::string *arg4 = 0 ;
84964   Dali::Actor *argp2 ;
84965
84966   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84967   argp2 = (Dali::Actor *)jarg2;
84968   if (!argp2) {
84969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84970     return ;
84971   }
84972   arg2 = *argp2;
84973   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84974   if (!jarg4) {
84975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84976     return ;
84977   }
84978   std::string arg4_str(jarg4);
84979   arg4 = &arg4_str;
84980   {
84981     try {
84982       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84983     } catch (std::out_of_range& e) {
84984       {
84985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84986       };
84987     } catch (std::exception& e) {
84988       {
84989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84990       };
84991     } catch (Dali::DaliException e) {
84992       {
84993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84994       };
84995     } catch (...) {
84996       {
84997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84998       };
84999     }
85000   }
85001
85002
85003   //argout typemap for const std::string&
85004
85005 }
85006
85007
85008 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
85009   char * jresult ;
85010   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85011   Dali::Actor arg2 ;
85012   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
85013   Dali::Actor *argp2 ;
85014   std::string result;
85015
85016   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85017   argp2 = (Dali::Actor *)jarg2;
85018   if (!argp2) {
85019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85020     return 0;
85021   }
85022   arg2 = *argp2;
85023   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
85024   {
85025     try {
85026       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
85027     } catch (std::out_of_range& e) {
85028       {
85029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85030       };
85031     } catch (std::exception& e) {
85032       {
85033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85034       };
85035     } catch (Dali::DaliException e) {
85036       {
85037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85038       };
85039     } catch (...) {
85040       {
85041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85042       };
85043     }
85044   }
85045
85046   jresult = SWIG_csharp_string_callback((&result)->c_str());
85047   return jresult;
85048 }
85049
85050
85051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
85052   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85053   Dali::Actor arg2 ;
85054   unsigned int arg3 ;
85055   Dali::Actor *argp2 ;
85056
85057   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85058   argp2 = (Dali::Actor *)jarg2;
85059   if (!argp2) {
85060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85061     return ;
85062   }
85063   arg2 = *argp2;
85064   arg3 = (unsigned int)jarg3;
85065   {
85066     try {
85067       (arg1)->SetFocusOrder(arg2,arg3);
85068     } catch (std::out_of_range& e) {
85069       {
85070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85071       };
85072     } catch (std::exception& e) {
85073       {
85074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85075       };
85076     } catch (Dali::DaliException e) {
85077       {
85078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85079       };
85080     } catch (...) {
85081       {
85082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85083       };
85084     }
85085   }
85086
85087 }
85088
85089
85090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
85091   unsigned int jresult ;
85092   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85093   Dali::Actor arg2 ;
85094   Dali::Actor *argp2 ;
85095   unsigned int result;
85096
85097   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85098   argp2 = (Dali::Actor *)jarg2;
85099   if (!argp2) {
85100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85101     return 0;
85102   }
85103   arg2 = *argp2;
85104   {
85105     try {
85106       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
85107     } catch (std::out_of_range& e) {
85108       {
85109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85110       };
85111     } catch (std::exception& e) {
85112       {
85113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85114       };
85115     } catch (Dali::DaliException e) {
85116       {
85117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85118       };
85119     } catch (...) {
85120       {
85121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85122       };
85123     }
85124   }
85125
85126   jresult = result;
85127   return jresult;
85128 }
85129
85130
85131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
85132   unsigned int jresult ;
85133   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85134   unsigned int result;
85135
85136   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85137   {
85138     try {
85139       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
85140     } catch (std::out_of_range& e) {
85141       {
85142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85143       };
85144     } catch (std::exception& e) {
85145       {
85146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85147       };
85148     } catch (Dali::DaliException e) {
85149       {
85150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85151       };
85152     } catch (...) {
85153       {
85154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85155       };
85156     }
85157   }
85158
85159   jresult = result;
85160   return jresult;
85161 }
85162
85163
85164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
85165   void * jresult ;
85166   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85167   unsigned int arg2 ;
85168   Dali::Actor result;
85169
85170   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85171   arg2 = (unsigned int)jarg2;
85172   {
85173     try {
85174       result = (arg1)->GetActorByFocusOrder(arg2);
85175     } catch (std::out_of_range& e) {
85176       {
85177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85178       };
85179     } catch (std::exception& e) {
85180       {
85181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85182       };
85183     } catch (Dali::DaliException e) {
85184       {
85185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85186       };
85187     } catch (...) {
85188       {
85189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85190       };
85191     }
85192   }
85193
85194   jresult = new Dali::Actor((const Dali::Actor &)result);
85195   return jresult;
85196 }
85197
85198
85199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
85200   unsigned int jresult ;
85201   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85202   Dali::Actor arg2 ;
85203   Dali::Actor *argp2 ;
85204   bool result;
85205
85206   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85207   argp2 = (Dali::Actor *)jarg2;
85208   if (!argp2) {
85209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85210     return 0;
85211   }
85212   arg2 = *argp2;
85213   {
85214     try {
85215       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
85216     } catch (std::out_of_range& e) {
85217       {
85218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85219       };
85220     } catch (std::exception& e) {
85221       {
85222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85223       };
85224     } catch (Dali::DaliException e) {
85225       {
85226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85227       };
85228     } catch (...) {
85229       {
85230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85231       };
85232     }
85233   }
85234
85235   jresult = result;
85236   return jresult;
85237 }
85238
85239
85240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
85241   void * jresult ;
85242   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85243   Dali::Actor result;
85244
85245   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85246   {
85247     try {
85248       result = (arg1)->GetCurrentFocusActor();
85249     } catch (std::out_of_range& e) {
85250       {
85251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85252       };
85253     } catch (std::exception& e) {
85254       {
85255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85256       };
85257     } catch (Dali::DaliException e) {
85258       {
85259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85260       };
85261     } catch (...) {
85262       {
85263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85264       };
85265     }
85266   }
85267
85268   jresult = new Dali::Actor((const Dali::Actor &)result);
85269   return jresult;
85270 }
85271
85272
85273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
85274   void * jresult ;
85275   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85276   Dali::Actor result;
85277
85278   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85279   {
85280     try {
85281       result = (arg1)->GetCurrentFocusGroup();
85282     } catch (std::out_of_range& e) {
85283       {
85284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85285       };
85286     } catch (std::exception& e) {
85287       {
85288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85289       };
85290     } catch (Dali::DaliException e) {
85291       {
85292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85293       };
85294     } catch (...) {
85295       {
85296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85297       };
85298     }
85299   }
85300
85301   jresult = new Dali::Actor((const Dali::Actor &)result);
85302   return jresult;
85303 }
85304
85305
85306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
85307   unsigned int jresult ;
85308   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85309   unsigned int result;
85310
85311   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85312   {
85313     try {
85314       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
85315     } catch (std::out_of_range& e) {
85316       {
85317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85318       };
85319     } catch (std::exception& e) {
85320       {
85321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85322       };
85323     } catch (Dali::DaliException e) {
85324       {
85325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85326       };
85327     } catch (...) {
85328       {
85329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85330       };
85331     }
85332   }
85333
85334   jresult = result;
85335   return jresult;
85336 }
85337
85338
85339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
85340   unsigned int jresult ;
85341   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85342   bool result;
85343
85344   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85345   {
85346     try {
85347       result = (bool)(arg1)->MoveFocusForward();
85348     } catch (std::out_of_range& e) {
85349       {
85350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85351       };
85352     } catch (std::exception& e) {
85353       {
85354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85355       };
85356     } catch (Dali::DaliException e) {
85357       {
85358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85359       };
85360     } catch (...) {
85361       {
85362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85363       };
85364     }
85365   }
85366
85367   jresult = result;
85368   return jresult;
85369 }
85370
85371
85372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
85373   unsigned int jresult ;
85374   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85375   bool result;
85376
85377   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85378   {
85379     try {
85380       result = (bool)(arg1)->MoveFocusBackward();
85381     } catch (std::out_of_range& e) {
85382       {
85383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85384       };
85385     } catch (std::exception& e) {
85386       {
85387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85388       };
85389     } catch (Dali::DaliException e) {
85390       {
85391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85392       };
85393     } catch (...) {
85394       {
85395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85396       };
85397     }
85398   }
85399
85400   jresult = result;
85401   return jresult;
85402 }
85403
85404
85405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
85406   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85407
85408   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85409   {
85410     try {
85411       (arg1)->ClearFocus();
85412     } catch (std::out_of_range& e) {
85413       {
85414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85415       };
85416     } catch (std::exception& e) {
85417       {
85418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85419       };
85420     } catch (Dali::DaliException e) {
85421       {
85422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85423       };
85424     } catch (...) {
85425       {
85426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85427       };
85428     }
85429   }
85430
85431 }
85432
85433
85434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
85435   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85436
85437   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85438   {
85439     try {
85440       (arg1)->Reset();
85441     } catch (std::out_of_range& e) {
85442       {
85443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85444       };
85445     } catch (std::exception& e) {
85446       {
85447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85448       };
85449     } catch (Dali::DaliException e) {
85450       {
85451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85452       };
85453     } catch (...) {
85454       {
85455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85456       };
85457     }
85458   }
85459
85460 }
85461
85462
85463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
85464   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85465   Dali::Actor arg2 ;
85466   bool arg3 ;
85467   Dali::Actor *argp2 ;
85468
85469   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85470   argp2 = (Dali::Actor *)jarg2;
85471   if (!argp2) {
85472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85473     return ;
85474   }
85475   arg2 = *argp2;
85476   arg3 = jarg3 ? true : false;
85477   {
85478     try {
85479       (arg1)->SetFocusGroup(arg2,arg3);
85480     } catch (std::out_of_range& e) {
85481       {
85482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85483       };
85484     } catch (std::exception& e) {
85485       {
85486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85487       };
85488     } catch (Dali::DaliException e) {
85489       {
85490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85491       };
85492     } catch (...) {
85493       {
85494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85495       };
85496     }
85497   }
85498
85499 }
85500
85501
85502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
85503   unsigned int jresult ;
85504   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85505   Dali::Actor arg2 ;
85506   Dali::Actor *argp2 ;
85507   bool result;
85508
85509   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85510   argp2 = (Dali::Actor *)jarg2;
85511   if (!argp2) {
85512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85513     return 0;
85514   }
85515   arg2 = *argp2;
85516   {
85517     try {
85518       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
85519     } catch (std::out_of_range& e) {
85520       {
85521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85522       };
85523     } catch (std::exception& e) {
85524       {
85525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85526       };
85527     } catch (Dali::DaliException e) {
85528       {
85529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85530       };
85531     } catch (...) {
85532       {
85533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85534       };
85535     }
85536   }
85537
85538   jresult = result;
85539   return jresult;
85540 }
85541
85542
85543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
85544   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85545   bool arg2 ;
85546
85547   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85548   arg2 = jarg2 ? true : false;
85549   {
85550     try {
85551       (arg1)->SetGroupMode(arg2);
85552     } catch (std::out_of_range& e) {
85553       {
85554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85555       };
85556     } catch (std::exception& e) {
85557       {
85558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85559       };
85560     } catch (Dali::DaliException e) {
85561       {
85562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85563       };
85564     } catch (...) {
85565       {
85566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85567       };
85568     }
85569   }
85570
85571 }
85572
85573
85574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85575   unsigned int jresult ;
85576   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85577   bool result;
85578
85579   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85580   {
85581     try {
85582       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85583     } catch (std::out_of_range& e) {
85584       {
85585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85586       };
85587     } catch (std::exception& e) {
85588       {
85589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85590       };
85591     } catch (Dali::DaliException e) {
85592       {
85593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85594       };
85595     } catch (...) {
85596       {
85597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85598       };
85599     }
85600   }
85601
85602   jresult = result;
85603   return jresult;
85604 }
85605
85606
85607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85608   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85609   bool arg2 ;
85610
85611   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85612   arg2 = jarg2 ? true : false;
85613   {
85614     try {
85615       (arg1)->SetWrapMode(arg2);
85616     } catch (std::out_of_range& e) {
85617       {
85618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85619       };
85620     } catch (std::exception& e) {
85621       {
85622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85623       };
85624     } catch (Dali::DaliException e) {
85625       {
85626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85627       };
85628     } catch (...) {
85629       {
85630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85631       };
85632     }
85633   }
85634
85635 }
85636
85637
85638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85639   unsigned int jresult ;
85640   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85641   bool result;
85642
85643   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85644   {
85645     try {
85646       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85647     } catch (std::out_of_range& e) {
85648       {
85649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85650       };
85651     } catch (std::exception& e) {
85652       {
85653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85654       };
85655     } catch (Dali::DaliException e) {
85656       {
85657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85658       };
85659     } catch (...) {
85660       {
85661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85662       };
85663     }
85664   }
85665
85666   jresult = result;
85667   return jresult;
85668 }
85669
85670
85671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85672   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85673   Dali::Actor arg2 ;
85674   Dali::Actor *argp2 ;
85675
85676   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85677   argp2 = (Dali::Actor *)jarg2;
85678   if (!argp2) {
85679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85680     return ;
85681   }
85682   arg2 = *argp2;
85683   {
85684     try {
85685       (arg1)->SetFocusIndicatorActor(arg2);
85686     } catch (std::out_of_range& e) {
85687       {
85688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85689       };
85690     } catch (std::exception& e) {
85691       {
85692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85693       };
85694     } catch (Dali::DaliException e) {
85695       {
85696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85697       };
85698     } catch (...) {
85699       {
85700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85701       };
85702     }
85703   }
85704
85705 }
85706
85707
85708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85709   void * jresult ;
85710   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85711   Dali::Actor result;
85712
85713   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85714   {
85715     try {
85716       result = (arg1)->GetFocusIndicatorActor();
85717     } catch (std::out_of_range& e) {
85718       {
85719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85720       };
85721     } catch (std::exception& e) {
85722       {
85723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85724       };
85725     } catch (Dali::DaliException e) {
85726       {
85727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85728       };
85729     } catch (...) {
85730       {
85731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85732       };
85733     }
85734   }
85735
85736   jresult = new Dali::Actor((const Dali::Actor &)result);
85737   return jresult;
85738 }
85739
85740
85741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85742   void * jresult ;
85743   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85744   Dali::Actor arg2 ;
85745   Dali::Actor *argp2 ;
85746   Dali::Actor result;
85747
85748   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85749   argp2 = (Dali::Actor *)jarg2;
85750   if (!argp2) {
85751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85752     return 0;
85753   }
85754   arg2 = *argp2;
85755   {
85756     try {
85757       result = (arg1)->GetFocusGroup(arg2);
85758     } catch (std::out_of_range& e) {
85759       {
85760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85761       };
85762     } catch (std::exception& e) {
85763       {
85764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85765       };
85766     } catch (Dali::DaliException e) {
85767       {
85768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85769       };
85770     } catch (...) {
85771       {
85772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85773       };
85774     }
85775   }
85776
85777   jresult = new Dali::Actor((const Dali::Actor &)result);
85778   return jresult;
85779 }
85780
85781
85782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85783   void * jresult ;
85784   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85785   Dali::Vector2 result;
85786
85787   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85788   {
85789     try {
85790       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85791     } catch (std::out_of_range& e) {
85792       {
85793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85794       };
85795     } catch (std::exception& e) {
85796       {
85797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85798       };
85799     } catch (Dali::DaliException e) {
85800       {
85801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85802       };
85803     } catch (...) {
85804       {
85805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85806       };
85807     }
85808   }
85809
85810   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85811   return jresult;
85812 }
85813
85814
85815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85816   void * jresult ;
85817   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85818   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85819
85820   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85821   {
85822     try {
85823       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85824     } catch (std::out_of_range& e) {
85825       {
85826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85827       };
85828     } catch (std::exception& e) {
85829       {
85830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85831       };
85832     } catch (Dali::DaliException e) {
85833       {
85834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85835       };
85836     } catch (...) {
85837       {
85838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85839       };
85840     }
85841   }
85842
85843   jresult = (void *)result;
85844   return jresult;
85845 }
85846
85847
85848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85849   void * jresult ;
85850   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85851   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85852
85853   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85854   {
85855     try {
85856       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85857     } catch (std::out_of_range& e) {
85858       {
85859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85860       };
85861     } catch (std::exception& e) {
85862       {
85863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85864       };
85865     } catch (Dali::DaliException e) {
85866       {
85867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85868       };
85869     } catch (...) {
85870       {
85871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85872       };
85873     }
85874   }
85875
85876   jresult = (void *)result;
85877   return jresult;
85878 }
85879
85880
85881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85882   void * jresult ;
85883   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85884   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85885
85886   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85887   {
85888     try {
85889       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85890     } catch (std::out_of_range& e) {
85891       {
85892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85893       };
85894     } catch (std::exception& e) {
85895       {
85896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85897       };
85898     } catch (Dali::DaliException e) {
85899       {
85900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85901       };
85902     } catch (...) {
85903       {
85904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85905       };
85906     }
85907   }
85908
85909   jresult = (void *)result;
85910   return jresult;
85911 }
85912
85913
85914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85915   void * jresult ;
85916   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85917   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85918
85919   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85920   {
85921     try {
85922       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85923     } catch (std::out_of_range& e) {
85924       {
85925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85926       };
85927     } catch (std::exception& e) {
85928       {
85929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85930       };
85931     } catch (Dali::DaliException e) {
85932       {
85933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85934       };
85935     } catch (...) {
85936       {
85937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85938       };
85939     }
85940   }
85941
85942   jresult = (void *)result;
85943   return jresult;
85944 }
85945
85946
85947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85948   void * jresult ;
85949   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85950   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85951
85952   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85953   {
85954     try {
85955       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85956     } catch (std::out_of_range& e) {
85957       {
85958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85959       };
85960     } catch (std::exception& e) {
85961       {
85962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85963       };
85964     } catch (Dali::DaliException e) {
85965       {
85966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85967       };
85968     } catch (...) {
85969       {
85970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85971       };
85972     }
85973   }
85974
85975   jresult = (void *)result;
85976   return jresult;
85977 }
85978
85979
85980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85981   void * jresult ;
85982   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85983   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85984
85985   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85986   {
85987     try {
85988       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85989     } catch (std::out_of_range& e) {
85990       {
85991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85992       };
85993     } catch (std::exception& e) {
85994       {
85995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85996       };
85997     } catch (Dali::DaliException e) {
85998       {
85999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86000       };
86001     } catch (...) {
86002       {
86003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86004       };
86005     }
86006   }
86007
86008   jresult = (void *)result;
86009   return jresult;
86010 }
86011
86012
86013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
86014   void * jresult ;
86015   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86016   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86017
86018   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86019   {
86020     try {
86021       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
86022     } catch (std::out_of_range& e) {
86023       {
86024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86025       };
86026     } catch (std::exception& e) {
86027       {
86028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86029       };
86030     } catch (Dali::DaliException e) {
86031       {
86032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86033       };
86034     } catch (...) {
86035       {
86036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86037       };
86038     }
86039   }
86040
86041   jresult = (void *)result;
86042   return jresult;
86043 }
86044
86045
86046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
86047   void * jresult ;
86048   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86049   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86050
86051   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86052   {
86053     try {
86054       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
86055     } catch (std::out_of_range& e) {
86056       {
86057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86058       };
86059     } catch (std::exception& e) {
86060       {
86061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86062       };
86063     } catch (Dali::DaliException e) {
86064       {
86065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86066       };
86067     } catch (...) {
86068       {
86069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86070       };
86071     }
86072   }
86073
86074   jresult = (void *)result;
86075   return jresult;
86076 }
86077
86078
86079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
86080   void * jresult ;
86081   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86082   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86083
86084   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86085   {
86086     try {
86087       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
86088     } catch (std::out_of_range& e) {
86089       {
86090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86091       };
86092     } catch (std::exception& e) {
86093       {
86094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86095       };
86096     } catch (Dali::DaliException e) {
86097       {
86098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86099       };
86100     } catch (...) {
86101       {
86102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86103       };
86104     }
86105   }
86106
86107   jresult = (void *)result;
86108   return jresult;
86109 }
86110
86111
86112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
86113   void * jresult ;
86114   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86115   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86116
86117   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86118   {
86119     try {
86120       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
86121     } catch (std::out_of_range& e) {
86122       {
86123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86124       };
86125     } catch (std::exception& e) {
86126       {
86127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86128       };
86129     } catch (Dali::DaliException e) {
86130       {
86131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86132       };
86133     } catch (...) {
86134       {
86135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86136       };
86137     }
86138   }
86139
86140   jresult = (void *)result;
86141   return jresult;
86142 }
86143
86144
86145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
86146   void * jresult ;
86147   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86148   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86149
86150   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86151   {
86152     try {
86153       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
86154     } catch (std::out_of_range& e) {
86155       {
86156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86157       };
86158     } catch (std::exception& e) {
86159       {
86160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86161       };
86162     } catch (Dali::DaliException e) {
86163       {
86164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86165       };
86166     } catch (...) {
86167       {
86168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86169       };
86170     }
86171   }
86172
86173   jresult = (void *)result;
86174   return jresult;
86175 }
86176
86177
86178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
86179   void * jresult ;
86180   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86181   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86182
86183   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86184   {
86185     try {
86186       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
86187     } catch (std::out_of_range& e) {
86188       {
86189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86190       };
86191     } catch (std::exception& e) {
86192       {
86193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86194       };
86195     } catch (Dali::DaliException e) {
86196       {
86197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86198       };
86199     } catch (...) {
86200       {
86201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86202       };
86203     }
86204   }
86205
86206   jresult = (void *)result;
86207   return jresult;
86208 }
86209
86210
86211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
86212   void * jresult ;
86213   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86214   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86215
86216   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86217   {
86218     try {
86219       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
86220     } catch (std::out_of_range& e) {
86221       {
86222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86223       };
86224     } catch (std::exception& e) {
86225       {
86226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86227       };
86228     } catch (Dali::DaliException e) {
86229       {
86230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86231       };
86232     } catch (...) {
86233       {
86234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86235       };
86236     }
86237   }
86238
86239   jresult = (void *)result;
86240   return jresult;
86241 }
86242
86243
86244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
86245   void * jresult ;
86246   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86247   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86248
86249   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86250   {
86251     try {
86252       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
86253     } catch (std::out_of_range& e) {
86254       {
86255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86256       };
86257     } catch (std::exception& e) {
86258       {
86259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86260       };
86261     } catch (Dali::DaliException e) {
86262       {
86263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86264       };
86265     } catch (...) {
86266       {
86267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86268       };
86269     }
86270   }
86271
86272   jresult = (void *)result;
86273   return jresult;
86274 }
86275
86276
86277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
86278   void * jresult ;
86279   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86280   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86281
86282   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86283   {
86284     try {
86285       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
86286     } catch (std::out_of_range& e) {
86287       {
86288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86289       };
86290     } catch (std::exception& e) {
86291       {
86292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86293       };
86294     } catch (Dali::DaliException e) {
86295       {
86296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86297       };
86298     } catch (...) {
86299       {
86300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86301       };
86302     }
86303   }
86304
86305   jresult = (void *)result;
86306   return jresult;
86307 }
86308
86309
86310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
86311   void * jresult ;
86312   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86313   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86314
86315   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86316   {
86317     try {
86318       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
86319     } catch (std::out_of_range& e) {
86320       {
86321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86322       };
86323     } catch (std::exception& e) {
86324       {
86325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86326       };
86327     } catch (Dali::DaliException e) {
86328       {
86329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86330       };
86331     } catch (...) {
86332       {
86333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86334       };
86335     }
86336   }
86337
86338   jresult = (void *)result;
86339   return jresult;
86340 }
86341
86342
86343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
86344   void * jresult ;
86345   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86346   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86347
86348   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86349   {
86350     try {
86351       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
86352     } catch (std::out_of_range& e) {
86353       {
86354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86355       };
86356     } catch (std::exception& e) {
86357       {
86358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86359       };
86360     } catch (Dali::DaliException e) {
86361       {
86362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86363       };
86364     } catch (...) {
86365       {
86366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86367       };
86368     }
86369   }
86370
86371   jresult = (void *)result;
86372   return jresult;
86373 }
86374
86375
86376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
86377   void * jresult ;
86378   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86379   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86380
86381   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86382   {
86383     try {
86384       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
86385     } catch (std::out_of_range& e) {
86386       {
86387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86388       };
86389     } catch (std::exception& e) {
86390       {
86391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86392       };
86393     } catch (Dali::DaliException e) {
86394       {
86395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86396       };
86397     } catch (...) {
86398       {
86399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86400       };
86401     }
86402   }
86403
86404   jresult = (void *)result;
86405   return jresult;
86406 }
86407
86408
86409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
86410   void * jresult ;
86411   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86412   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86413
86414   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86415   {
86416     try {
86417       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
86418     } catch (std::out_of_range& e) {
86419       {
86420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86421       };
86422     } catch (std::exception& e) {
86423       {
86424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86425       };
86426     } catch (Dali::DaliException e) {
86427       {
86428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86429       };
86430     } catch (...) {
86431       {
86432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86433       };
86434     }
86435   }
86436
86437   jresult = (void *)result;
86438   return jresult;
86439 }
86440
86441
86442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
86443   void * jresult ;
86444   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86445   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86446
86447   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86448   {
86449     try {
86450       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
86451     } catch (std::out_of_range& e) {
86452       {
86453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86454       };
86455     } catch (std::exception& e) {
86456       {
86457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86458       };
86459     } catch (Dali::DaliException e) {
86460       {
86461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86462       };
86463     } catch (...) {
86464       {
86465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86466       };
86467     }
86468   }
86469
86470   jresult = (void *)result;
86471   return jresult;
86472 }
86473
86474
86475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
86476   void * jresult ;
86477   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86478   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86479
86480   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86481   {
86482     try {
86483       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
86484     } catch (std::out_of_range& e) {
86485       {
86486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86487       };
86488     } catch (std::exception& e) {
86489       {
86490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86491       };
86492     } catch (Dali::DaliException e) {
86493       {
86494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86495       };
86496     } catch (...) {
86497       {
86498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86499       };
86500     }
86501   }
86502
86503   jresult = (void *)result;
86504   return jresult;
86505 }
86506
86507
86508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
86509   void * jresult ;
86510   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86511   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86512
86513   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86514   {
86515     try {
86516       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
86517     } catch (std::out_of_range& e) {
86518       {
86519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86520       };
86521     } catch (std::exception& e) {
86522       {
86523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86524       };
86525     } catch (Dali::DaliException e) {
86526       {
86527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86528       };
86529     } catch (...) {
86530       {
86531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86532       };
86533     }
86534   }
86535
86536   jresult = (void *)result;
86537   return jresult;
86538 }
86539
86540
86541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
86542   void * jresult ;
86543   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86544   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86545
86546   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86547   {
86548     try {
86549       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86550     } catch (std::out_of_range& e) {
86551       {
86552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86553       };
86554     } catch (std::exception& e) {
86555       {
86556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86557       };
86558     } catch (Dali::DaliException e) {
86559       {
86560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86561       };
86562     } catch (...) {
86563       {
86564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86565       };
86566     }
86567   }
86568
86569   jresult = (void *)result;
86570   return jresult;
86571 }
86572
86573
86574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86575   void * jresult ;
86576   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86577   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86578
86579   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86580   {
86581     try {
86582       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86583     } catch (std::out_of_range& e) {
86584       {
86585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86586       };
86587     } catch (std::exception& e) {
86588       {
86589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86590       };
86591     } catch (Dali::DaliException e) {
86592       {
86593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86594       };
86595     } catch (...) {
86596       {
86597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86598       };
86599     }
86600   }
86601
86602   jresult = (void *)result;
86603   return jresult;
86604 }
86605
86606
86607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86608   void * jresult ;
86609   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86610   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86611
86612   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86613   {
86614     try {
86615       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86616     } catch (std::out_of_range& e) {
86617       {
86618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86619       };
86620     } catch (std::exception& e) {
86621       {
86622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86623       };
86624     } catch (Dali::DaliException e) {
86625       {
86626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86627       };
86628     } catch (...) {
86629       {
86630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86631       };
86632     }
86633   }
86634
86635   jresult = (void *)result;
86636   return jresult;
86637 }
86638
86639
86640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86641   void * jresult ;
86642   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86643   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86644
86645   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86646   {
86647     try {
86648       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86649     } catch (std::out_of_range& e) {
86650       {
86651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86652       };
86653     } catch (std::exception& e) {
86654       {
86655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86656       };
86657     } catch (Dali::DaliException e) {
86658       {
86659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86660       };
86661     } catch (...) {
86662       {
86663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86664       };
86665     }
86666   }
86667
86668   jresult = (void *)result;
86669   return jresult;
86670 }
86671
86672
86673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86674   void * jresult ;
86675   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86676   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86677
86678   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86679   {
86680     try {
86681       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86682     } catch (std::out_of_range& e) {
86683       {
86684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86685       };
86686     } catch (std::exception& e) {
86687       {
86688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86689       };
86690     } catch (Dali::DaliException e) {
86691       {
86692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86693       };
86694     } catch (...) {
86695       {
86696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86697       };
86698     }
86699   }
86700
86701   jresult = (void *)result;
86702   return jresult;
86703 }
86704
86705
86706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86707   void * jresult ;
86708   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86709   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86710
86711   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86712   {
86713     try {
86714       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86715     } catch (std::out_of_range& e) {
86716       {
86717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86718       };
86719     } catch (std::exception& e) {
86720       {
86721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86722       };
86723     } catch (Dali::DaliException e) {
86724       {
86725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86726       };
86727     } catch (...) {
86728       {
86729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86730       };
86731     }
86732   }
86733
86734   jresult = (void *)result;
86735   return jresult;
86736 }
86737
86738
86739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86740   void * jresult ;
86741   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86742   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86743
86744   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86745   {
86746     try {
86747       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86748     } catch (std::out_of_range& e) {
86749       {
86750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86751       };
86752     } catch (std::exception& e) {
86753       {
86754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86755       };
86756     } catch (Dali::DaliException e) {
86757       {
86758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86759       };
86760     } catch (...) {
86761       {
86762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86763       };
86764     }
86765   }
86766
86767   jresult = (void *)result;
86768   return jresult;
86769 }
86770
86771
86772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86773   void * jresult ;
86774   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86775   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86776
86777   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86778   {
86779     try {
86780       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86781     } catch (std::out_of_range& e) {
86782       {
86783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86784       };
86785     } catch (std::exception& e) {
86786       {
86787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86788       };
86789     } catch (Dali::DaliException e) {
86790       {
86791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86792       };
86793     } catch (...) {
86794       {
86795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86796       };
86797     }
86798   }
86799
86800   jresult = (void *)result;
86801   return jresult;
86802 }
86803
86804
86805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86806   void * jresult ;
86807   Dali::Toolkit::StyleManager *result = 0 ;
86808
86809   {
86810     try {
86811       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86812     } catch (std::out_of_range& e) {
86813       {
86814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86815       };
86816     } catch (std::exception& e) {
86817       {
86818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86819       };
86820     } catch (Dali::DaliException e) {
86821       {
86822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86823       };
86824     } catch (...) {
86825       {
86826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86827       };
86828     }
86829   }
86830
86831   jresult = (void *)result;
86832   return jresult;
86833 }
86834
86835
86836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86837   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86838
86839   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86840   {
86841     try {
86842       delete arg1;
86843     } catch (std::out_of_range& e) {
86844       {
86845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86846       };
86847     } catch (std::exception& e) {
86848       {
86849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86850       };
86851     } catch (Dali::DaliException e) {
86852       {
86853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86854       };
86855     } catch (...) {
86856       {
86857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86858       };
86859     }
86860   }
86861
86862 }
86863
86864
86865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86866   void * jresult ;
86867   Dali::Toolkit::StyleManager result;
86868
86869   {
86870     try {
86871       result = Dali::Toolkit::StyleManager::Get();
86872     } catch (std::out_of_range& e) {
86873       {
86874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86875       };
86876     } catch (std::exception& e) {
86877       {
86878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86879       };
86880     } catch (Dali::DaliException e) {
86881       {
86882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86883       };
86884     } catch (...) {
86885       {
86886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86887       };
86888     }
86889   }
86890
86891   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86892   return jresult;
86893 }
86894
86895
86896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86897   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86898   std::string *arg2 = 0 ;
86899
86900   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86901   if (!jarg2) {
86902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86903     return ;
86904   }
86905   std::string arg2_str(jarg2);
86906   arg2 = &arg2_str;
86907   {
86908     try {
86909       (arg1)->ApplyTheme((std::string const &)*arg2);
86910     } catch (std::out_of_range& e) {
86911       {
86912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86913       };
86914     } catch (std::exception& e) {
86915       {
86916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86917       };
86918     } catch (Dali::DaliException e) {
86919       {
86920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86921       };
86922     } catch (...) {
86923       {
86924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86925       };
86926     }
86927   }
86928
86929
86930   //argout typemap for const std::string&
86931
86932 }
86933
86934
86935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86936   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86937
86938   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86939   {
86940     try {
86941       (arg1)->ApplyDefaultTheme();
86942     } catch (std::out_of_range& e) {
86943       {
86944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86945       };
86946     } catch (std::exception& e) {
86947       {
86948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86949       };
86950     } catch (Dali::DaliException e) {
86951       {
86952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86953       };
86954     } catch (...) {
86955       {
86956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86957       };
86958     }
86959   }
86960
86961 }
86962
86963
86964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86965   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86966   std::string *arg2 = 0 ;
86967   Dali::Property::Value *arg3 = 0 ;
86968
86969   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86970   if (!jarg2) {
86971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86972     return ;
86973   }
86974   std::string arg2_str(jarg2);
86975   arg2 = &arg2_str;
86976   arg3 = (Dali::Property::Value *)jarg3;
86977   if (!arg3) {
86978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86979     return ;
86980   }
86981   {
86982     try {
86983       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86984     } catch (std::out_of_range& e) {
86985       {
86986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86987       };
86988     } catch (std::exception& e) {
86989       {
86990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86991       };
86992     } catch (Dali::DaliException e) {
86993       {
86994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86995       };
86996     } catch (...) {
86997       {
86998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86999       };
87000     }
87001   }
87002
87003
87004   //argout typemap for const std::string&
87005
87006 }
87007
87008
87009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
87010   unsigned int jresult ;
87011   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87012   std::string *arg2 = 0 ;
87013   Dali::Property::Value *arg3 = 0 ;
87014   bool result;
87015
87016   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87017   if (!jarg2) {
87018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87019     return 0;
87020   }
87021   std::string arg2_str(jarg2);
87022   arg2 = &arg2_str;
87023   arg3 = (Dali::Property::Value *)jarg3;
87024   if (!arg3) {
87025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
87026     return 0;
87027   }
87028   {
87029     try {
87030       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
87031     } catch (std::out_of_range& e) {
87032       {
87033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87034       };
87035     } catch (std::exception& e) {
87036       {
87037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87038       };
87039     } catch (Dali::DaliException e) {
87040       {
87041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87042       };
87043     } catch (...) {
87044       {
87045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87046       };
87047     }
87048   }
87049
87050   jresult = result;
87051
87052   //argout typemap for const std::string&
87053
87054   return jresult;
87055 }
87056
87057
87058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
87059   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87060   Dali::Toolkit::Control arg2 ;
87061   std::string *arg3 = 0 ;
87062   std::string *arg4 = 0 ;
87063   Dali::Toolkit::Control *argp2 ;
87064
87065   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87066   argp2 = (Dali::Toolkit::Control *)jarg2;
87067   if (!argp2) {
87068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
87069     return ;
87070   }
87071   arg2 = *argp2;
87072   if (!jarg3) {
87073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87074     return ;
87075   }
87076   std::string arg3_str(jarg3);
87077   arg3 = &arg3_str;
87078   if (!jarg4) {
87079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87080     return ;
87081   }
87082   std::string arg4_str(jarg4);
87083   arg4 = &arg4_str;
87084   {
87085     try {
87086       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
87087     } catch (std::out_of_range& e) {
87088       {
87089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87090       };
87091     } catch (std::exception& e) {
87092       {
87093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87094       };
87095     } catch (Dali::DaliException e) {
87096       {
87097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87098       };
87099     } catch (...) {
87100       {
87101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87102       };
87103     }
87104   }
87105
87106
87107   //argout typemap for const std::string&
87108
87109
87110   //argout typemap for const std::string&
87111
87112 }
87113
87114
87115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
87116   void * jresult ;
87117   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87118   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
87119
87120   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87121   {
87122     try {
87123       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
87124     } catch (std::out_of_range& e) {
87125       {
87126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87127       };
87128     } catch (std::exception& e) {
87129       {
87130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87131       };
87132     } catch (Dali::DaliException e) {
87133       {
87134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87135       };
87136     } catch (...) {
87137       {
87138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87139       };
87140     }
87141   }
87142
87143   jresult = (void *)result;
87144   return jresult;
87145 }
87146
87147
87148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
87149   int jresult ;
87150   int result;
87151
87152   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
87153   jresult = (int)result;
87154   return jresult;
87155 }
87156
87157
87158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
87159   int jresult ;
87160   int result;
87161
87162   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
87163   jresult = (int)result;
87164   return jresult;
87165 }
87166
87167
87168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
87169   int jresult ;
87170   int result;
87171
87172   result = (int)Dali::Toolkit::Slider::Property::VALUE;
87173   jresult = (int)result;
87174   return jresult;
87175 }
87176
87177
87178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
87179   int jresult ;
87180   int result;
87181
87182   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
87183   jresult = (int)result;
87184   return jresult;
87185 }
87186
87187
87188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
87189   int jresult ;
87190   int result;
87191
87192   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
87193   jresult = (int)result;
87194   return jresult;
87195 }
87196
87197
87198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
87199   int jresult ;
87200   int result;
87201
87202   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
87203   jresult = (int)result;
87204   return jresult;
87205 }
87206
87207
87208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
87209   int jresult ;
87210   int result;
87211
87212   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
87213   jresult = (int)result;
87214   return jresult;
87215 }
87216
87217
87218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
87219   int jresult ;
87220   int result;
87221
87222   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
87223   jresult = (int)result;
87224   return jresult;
87225 }
87226
87227
87228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
87229   int jresult ;
87230   int result;
87231
87232   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
87233   jresult = (int)result;
87234   return jresult;
87235 }
87236
87237
87238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
87239   int jresult ;
87240   int result;
87241
87242   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
87243   jresult = (int)result;
87244   return jresult;
87245 }
87246
87247
87248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
87249   int jresult ;
87250   int result;
87251
87252   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
87253   jresult = (int)result;
87254   return jresult;
87255 }
87256
87257
87258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
87259   int jresult ;
87260   int result;
87261
87262   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
87263   jresult = (int)result;
87264   return jresult;
87265 }
87266
87267
87268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
87269   int jresult ;
87270   int result;
87271
87272   result = (int)Dali::Toolkit::Slider::Property::MARKS;
87273   jresult = (int)result;
87274   return jresult;
87275 }
87276
87277
87278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
87279   int jresult ;
87280   int result;
87281
87282   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
87283   jresult = (int)result;
87284   return jresult;
87285 }
87286
87287
87288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
87289   int jresult ;
87290   int result;
87291
87292   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
87293   jresult = (int)result;
87294   return jresult;
87295 }
87296
87297
87298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
87299   void * jresult ;
87300   Dali::Toolkit::Slider::Property *result = 0 ;
87301
87302   {
87303     try {
87304       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
87305     } catch (std::out_of_range& e) {
87306       {
87307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87308       };
87309     } catch (std::exception& e) {
87310       {
87311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87312       };
87313     } catch (Dali::DaliException e) {
87314       {
87315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87316       };
87317     } catch (...) {
87318       {
87319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87320       };
87321     }
87322   }
87323
87324   jresult = (void *)result;
87325   return jresult;
87326 }
87327
87328
87329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
87330   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
87331
87332   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
87333   {
87334     try {
87335       delete arg1;
87336     } catch (std::out_of_range& e) {
87337       {
87338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87339       };
87340     } catch (std::exception& e) {
87341       {
87342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87343       };
87344     } catch (Dali::DaliException e) {
87345       {
87346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87347       };
87348     } catch (...) {
87349       {
87350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87351       };
87352     }
87353   }
87354
87355 }
87356
87357
87358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
87359   void * jresult ;
87360   Dali::Toolkit::Slider result;
87361
87362   {
87363     try {
87364       result = Dali::Toolkit::Slider::New();
87365     } catch (std::out_of_range& e) {
87366       {
87367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87368       };
87369     } catch (std::exception& e) {
87370       {
87371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87372       };
87373     } catch (Dali::DaliException e) {
87374       {
87375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87376       };
87377     } catch (...) {
87378       {
87379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87380       };
87381     }
87382   }
87383
87384   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87385   return jresult;
87386 }
87387
87388
87389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
87390   void * jresult ;
87391   Dali::Toolkit::Slider *result = 0 ;
87392
87393   {
87394     try {
87395       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
87396     } catch (std::out_of_range& e) {
87397       {
87398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87399       };
87400     } catch (std::exception& e) {
87401       {
87402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87403       };
87404     } catch (Dali::DaliException e) {
87405       {
87406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87407       };
87408     } catch (...) {
87409       {
87410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87411       };
87412     }
87413   }
87414
87415   jresult = (void *)result;
87416   return jresult;
87417 }
87418
87419
87420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
87421   void * jresult ;
87422   Dali::Toolkit::Slider *arg1 = 0 ;
87423   Dali::Toolkit::Slider *result = 0 ;
87424
87425   arg1 = (Dali::Toolkit::Slider *)jarg1;
87426   if (!arg1) {
87427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87428     return 0;
87429   }
87430   {
87431     try {
87432       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
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_Slider_Assign(void * jarg1, void * jarg2) {
87458   void * jresult ;
87459   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87460   Dali::Toolkit::Slider *arg2 = 0 ;
87461   Dali::Toolkit::Slider *result = 0 ;
87462
87463   arg1 = (Dali::Toolkit::Slider *)jarg1;
87464   arg2 = (Dali::Toolkit::Slider *)jarg2;
87465   if (!arg2) {
87466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87467     return 0;
87468   }
87469   {
87470     try {
87471       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
87472     } catch (std::out_of_range& e) {
87473       {
87474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87475       };
87476     } catch (std::exception& e) {
87477       {
87478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87479       };
87480     } catch (Dali::DaliException e) {
87481       {
87482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87483       };
87484     } catch (...) {
87485       {
87486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87487       };
87488     }
87489   }
87490
87491   jresult = (void *)result;
87492   return jresult;
87493 }
87494
87495
87496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
87497   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87498
87499   arg1 = (Dali::Toolkit::Slider *)jarg1;
87500   {
87501     try {
87502       delete arg1;
87503     } catch (std::out_of_range& e) {
87504       {
87505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87506       };
87507     } catch (std::exception& e) {
87508       {
87509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87510       };
87511     } catch (Dali::DaliException e) {
87512       {
87513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87514       };
87515     } catch (...) {
87516       {
87517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87518       };
87519     }
87520   }
87521
87522 }
87523
87524
87525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
87526   void * jresult ;
87527   Dali::BaseHandle arg1 ;
87528   Dali::BaseHandle *argp1 ;
87529   Dali::Toolkit::Slider result;
87530
87531   argp1 = (Dali::BaseHandle *)jarg1;
87532   if (!argp1) {
87533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87534     return 0;
87535   }
87536   arg1 = *argp1;
87537   {
87538     try {
87539       result = Dali::Toolkit::Slider::DownCast(arg1);
87540     } catch (std::out_of_range& e) {
87541       {
87542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87543       };
87544     } catch (std::exception& e) {
87545       {
87546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87547       };
87548     } catch (Dali::DaliException e) {
87549       {
87550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87551       };
87552     } catch (...) {
87553       {
87554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87555       };
87556     }
87557   }
87558
87559   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87560   return jresult;
87561 }
87562
87563
87564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87565   void * jresult ;
87566   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87567   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87568
87569   arg1 = (Dali::Toolkit::Slider *)jarg1;
87570   {
87571     try {
87572       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87573     } catch (std::out_of_range& e) {
87574       {
87575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87576       };
87577     } catch (std::exception& e) {
87578       {
87579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87580       };
87581     } catch (Dali::DaliException e) {
87582       {
87583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87584       };
87585     } catch (...) {
87586       {
87587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87588       };
87589     }
87590   }
87591
87592   jresult = (void *)result;
87593   return jresult;
87594 }
87595
87596
87597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87598   void * jresult ;
87599   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87600   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87601
87602   arg1 = (Dali::Toolkit::Slider *)jarg1;
87603   {
87604     try {
87605       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87606     } catch (std::out_of_range& e) {
87607       {
87608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87609       };
87610     } catch (std::exception& e) {
87611       {
87612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87613       };
87614     } catch (Dali::DaliException e) {
87615       {
87616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87617       };
87618     } catch (...) {
87619       {
87620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87621       };
87622     }
87623   }
87624
87625   jresult = (void *)result;
87626   return jresult;
87627 }
87628
87629
87630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87631   void * jresult ;
87632   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87633   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87634
87635   arg1 = (Dali::Toolkit::Slider *)jarg1;
87636   {
87637     try {
87638       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87639     } catch (std::out_of_range& e) {
87640       {
87641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87642       };
87643     } catch (std::exception& e) {
87644       {
87645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87646       };
87647     } catch (Dali::DaliException e) {
87648       {
87649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87650       };
87651     } catch (...) {
87652       {
87653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87654       };
87655     }
87656   }
87657
87658   jresult = (void *)result;
87659   return jresult;
87660 }
87661
87662
87663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87664   int jresult ;
87665   int result;
87666
87667   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87668   jresult = (int)result;
87669   return jresult;
87670 }
87671
87672
87673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87674   int jresult ;
87675   int result;
87676
87677   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87678   jresult = (int)result;
87679   return jresult;
87680 }
87681
87682
87683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87684   int jresult ;
87685   int result;
87686
87687   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87688   jresult = (int)result;
87689   return jresult;
87690 }
87691
87692
87693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87694   int jresult ;
87695   int result;
87696
87697   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87698   jresult = (int)result;
87699   return jresult;
87700 }
87701
87702
87703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87704   int result;
87705
87706   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87707
87708   return result;
87709 }
87710
87711
87712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87713   void * jresult ;
87714   Dali::Toolkit::VideoView::Property *result = 0 ;
87715
87716   {
87717     try {
87718       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87719     } catch (std::out_of_range& e) {
87720       {
87721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87722       };
87723     } catch (std::exception& e) {
87724       {
87725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87726       };
87727     } catch (Dali::DaliException e) {
87728       {
87729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87730       };
87731     } catch (...) {
87732       {
87733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87734       };
87735     }
87736   }
87737
87738   jresult = (void *)result;
87739   return jresult;
87740 }
87741
87742
87743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87744   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87745
87746   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87747   {
87748     try {
87749       delete arg1;
87750     } catch (std::out_of_range& e) {
87751       {
87752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87753       };
87754     } catch (std::exception& e) {
87755       {
87756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87757       };
87758     } catch (Dali::DaliException e) {
87759       {
87760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87761       };
87762     } catch (...) {
87763       {
87764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87765       };
87766     }
87767   }
87768
87769 }
87770
87771
87772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87773   void * jresult ;
87774   Dali::Toolkit::VideoView result;
87775
87776   {
87777     try {
87778       result = Dali::Toolkit::VideoView::New();
87779     } catch (std::out_of_range& e) {
87780       {
87781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87782       };
87783     } catch (std::exception& e) {
87784       {
87785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87786       };
87787     } catch (Dali::DaliException e) {
87788       {
87789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87790       };
87791     } catch (...) {
87792       {
87793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87794       };
87795     }
87796   }
87797
87798   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87799   return jresult;
87800 }
87801
87802
87803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87804   void * jresult ;
87805   std::string *arg1 = 0 ;
87806   Dali::Toolkit::VideoView result;
87807
87808   if (!jarg1) {
87809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87810     return 0;
87811   }
87812   std::string arg1_str(jarg1);
87813   arg1 = &arg1_str;
87814   {
87815     try {
87816       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87817     } catch (std::out_of_range& e) {
87818       {
87819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87820       };
87821     } catch (std::exception& e) {
87822       {
87823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87824       };
87825     } catch (Dali::DaliException e) {
87826       {
87827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87828       };
87829     } catch (...) {
87830       {
87831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87832       };
87833     }
87834   }
87835
87836   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87837
87838   //argout typemap for const std::string&
87839
87840   return jresult;
87841 }
87842
87843
87844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87845   void * jresult ;
87846   Dali::Toolkit::VideoView *result = 0 ;
87847
87848   {
87849     try {
87850       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87851     } catch (std::out_of_range& e) {
87852       {
87853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87854       };
87855     } catch (std::exception& e) {
87856       {
87857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87858       };
87859     } catch (Dali::DaliException e) {
87860       {
87861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87862       };
87863     } catch (...) {
87864       {
87865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87866       };
87867     }
87868   }
87869
87870   jresult = (void *)result;
87871   return jresult;
87872 }
87873
87874
87875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87876   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87877
87878   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87879   {
87880     try {
87881       delete arg1;
87882     } catch (std::out_of_range& e) {
87883       {
87884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87885       };
87886     } catch (std::exception& e) {
87887       {
87888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87889       };
87890     } catch (Dali::DaliException e) {
87891       {
87892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87893       };
87894     } catch (...) {
87895       {
87896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87897       };
87898     }
87899   }
87900
87901 }
87902
87903
87904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87905   void * jresult ;
87906   Dali::Toolkit::VideoView *arg1 = 0 ;
87907   Dali::Toolkit::VideoView *result = 0 ;
87908
87909   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87910   if (!arg1) {
87911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87912     return 0;
87913   }
87914   {
87915     try {
87916       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87917     } catch (std::out_of_range& e) {
87918       {
87919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87920       };
87921     } catch (std::exception& e) {
87922       {
87923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87924       };
87925     } catch (Dali::DaliException e) {
87926       {
87927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87928       };
87929     } catch (...) {
87930       {
87931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87932       };
87933     }
87934   }
87935
87936   jresult = (void *)result;
87937   return jresult;
87938 }
87939
87940
87941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87942   void * jresult ;
87943   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87944   Dali::Toolkit::VideoView *arg2 = 0 ;
87945   Dali::Toolkit::VideoView *result = 0 ;
87946
87947   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87948   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87949   if (!arg2) {
87950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87951     return 0;
87952   }
87953   {
87954     try {
87955       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87956     } catch (std::out_of_range& e) {
87957       {
87958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87959       };
87960     } catch (std::exception& e) {
87961       {
87962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87963       };
87964     } catch (Dali::DaliException e) {
87965       {
87966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87967       };
87968     } catch (...) {
87969       {
87970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87971       };
87972     }
87973   }
87974
87975   jresult = (void *)result;
87976   return jresult;
87977 }
87978
87979
87980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87981   void * jresult ;
87982   Dali::BaseHandle arg1 ;
87983   Dali::BaseHandle *argp1 ;
87984   Dali::Toolkit::VideoView result;
87985
87986   argp1 = (Dali::BaseHandle *)jarg1;
87987   if (!argp1) {
87988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87989     return 0;
87990   }
87991   arg1 = *argp1;
87992   {
87993     try {
87994       result = Dali::Toolkit::VideoView::DownCast(arg1);
87995     } catch (std::out_of_range& e) {
87996       {
87997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87998       };
87999     } catch (std::exception& e) {
88000       {
88001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88002       };
88003     } catch (Dali::DaliException e) {
88004       {
88005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88006       };
88007     } catch (...) {
88008       {
88009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88010       };
88011     }
88012   }
88013
88014   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
88015   return jresult;
88016 }
88017
88018
88019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
88020   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88021
88022   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88023   {
88024     try {
88025       (arg1)->Play();
88026     } catch (std::out_of_range& e) {
88027       {
88028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88029       };
88030     } catch (std::exception& e) {
88031       {
88032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88033       };
88034     } catch (Dali::DaliException e) {
88035       {
88036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88037       };
88038     } catch (...) {
88039       {
88040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88041       };
88042     }
88043   }
88044
88045 }
88046
88047
88048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
88049   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88050
88051   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88052   {
88053     try {
88054       (arg1)->Pause();
88055     } catch (std::out_of_range& e) {
88056       {
88057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88058       };
88059     } catch (std::exception& e) {
88060       {
88061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88062       };
88063     } catch (Dali::DaliException e) {
88064       {
88065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88066       };
88067     } catch (...) {
88068       {
88069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88070       };
88071     }
88072   }
88073
88074 }
88075
88076
88077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
88078   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88079
88080   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88081   {
88082     try {
88083       (arg1)->Stop();
88084     } catch (std::out_of_range& e) {
88085       {
88086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88087       };
88088     } catch (std::exception& e) {
88089       {
88090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88091       };
88092     } catch (Dali::DaliException e) {
88093       {
88094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88095       };
88096     } catch (...) {
88097       {
88098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88099       };
88100     }
88101   }
88102
88103 }
88104
88105
88106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
88107   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88108   int arg2 ;
88109
88110   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88111   arg2 = (int)jarg2;
88112   {
88113     try {
88114       (arg1)->Forward(arg2);
88115     } catch (std::out_of_range& e) {
88116       {
88117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88118       };
88119     } catch (std::exception& e) {
88120       {
88121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88122       };
88123     } catch (Dali::DaliException e) {
88124       {
88125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88126       };
88127     } catch (...) {
88128       {
88129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88130       };
88131     }
88132   }
88133
88134 }
88135
88136
88137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
88138   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88139   int arg2 ;
88140
88141   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88142   arg2 = (int)jarg2;
88143   {
88144     try {
88145       (arg1)->Backward(arg2);
88146     } catch (std::out_of_range& e) {
88147       {
88148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88149       };
88150     } catch (std::exception& e) {
88151       {
88152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88153       };
88154     } catch (Dali::DaliException e) {
88155       {
88156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88157       };
88158     } catch (...) {
88159       {
88160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88161       };
88162     }
88163   }
88164
88165 }
88166
88167
88168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
88169   void * jresult ;
88170   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88171   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
88172
88173   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88174   {
88175     try {
88176       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
88177     } catch (std::out_of_range& e) {
88178       {
88179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88180       };
88181     } catch (std::exception& e) {
88182       {
88183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88184       };
88185     } catch (Dali::DaliException e) {
88186       {
88187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88188       };
88189     } catch (...) {
88190       {
88191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88192       };
88193     }
88194   }
88195
88196   jresult = (void *)result;
88197   return jresult;
88198 }
88199
88200
88201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
88202   int jresult ;
88203   int result;
88204
88205   result = (int)Dali::Toolkit::Popup::Property::TITLE;
88206   jresult = (int)result;
88207   return jresult;
88208 }
88209
88210
88211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
88212   int jresult ;
88213   int result;
88214
88215   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
88216   jresult = (int)result;
88217   return jresult;
88218 }
88219
88220
88221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
88222   int jresult ;
88223   int result;
88224
88225   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
88226   jresult = (int)result;
88227   return jresult;
88228 }
88229
88230
88231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
88232   int jresult ;
88233   int result;
88234
88235   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
88236   jresult = (int)result;
88237   return jresult;
88238 }
88239
88240
88241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
88242   int jresult ;
88243   int result;
88244
88245   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
88246   jresult = (int)result;
88247   return jresult;
88248 }
88249
88250
88251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
88252   int jresult ;
88253   int result;
88254
88255   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
88256   jresult = (int)result;
88257   return jresult;
88258 }
88259
88260
88261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
88262   int jresult ;
88263   int result;
88264
88265   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
88266   jresult = (int)result;
88267   return jresult;
88268 }
88269
88270
88271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
88272   int jresult ;
88273   int result;
88274
88275   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
88276   jresult = (int)result;
88277   return jresult;
88278 }
88279
88280
88281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
88282   int jresult ;
88283   int result;
88284
88285   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
88286   jresult = (int)result;
88287   return jresult;
88288 }
88289
88290
88291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
88292   int jresult ;
88293   int result;
88294
88295   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
88296   jresult = (int)result;
88297   return jresult;
88298 }
88299
88300
88301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
88302   int jresult ;
88303   int result;
88304
88305   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
88306   jresult = (int)result;
88307   return jresult;
88308 }
88309
88310
88311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
88312   int jresult ;
88313   int result;
88314
88315   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
88316   jresult = (int)result;
88317   return jresult;
88318 }
88319
88320
88321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
88322   int jresult ;
88323   int result;
88324
88325   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
88326   jresult = (int)result;
88327   return jresult;
88328 }
88329
88330
88331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
88332   int jresult ;
88333   int result;
88334
88335   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
88336   jresult = (int)result;
88337   return jresult;
88338 }
88339
88340
88341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
88342   int jresult ;
88343   int result;
88344
88345   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
88346   jresult = (int)result;
88347   return jresult;
88348 }
88349
88350
88351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
88352   int jresult ;
88353   int result;
88354
88355   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
88356   jresult = (int)result;
88357   return jresult;
88358 }
88359
88360
88361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
88362   int jresult ;
88363   int result;
88364
88365   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
88366   jresult = (int)result;
88367   return jresult;
88368 }
88369
88370
88371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
88372   int jresult ;
88373   int result;
88374
88375   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
88376   jresult = (int)result;
88377   return jresult;
88378 }
88379
88380
88381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
88382   int jresult ;
88383   int result;
88384
88385   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
88386   jresult = (int)result;
88387   return jresult;
88388 }
88389
88390
88391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
88392   int jresult ;
88393   int result;
88394
88395   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
88396   jresult = (int)result;
88397   return jresult;
88398 }
88399
88400
88401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
88402   int jresult ;
88403   int result;
88404
88405   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
88406   jresult = (int)result;
88407   return jresult;
88408 }
88409
88410
88411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
88412   void * jresult ;
88413   Dali::Toolkit::Popup::Property *result = 0 ;
88414
88415   {
88416     try {
88417       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
88418     } catch (std::out_of_range& e) {
88419       {
88420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88421       };
88422     } catch (std::exception& e) {
88423       {
88424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88425       };
88426     } catch (Dali::DaliException e) {
88427       {
88428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88429       };
88430     } catch (...) {
88431       {
88432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88433       };
88434     }
88435   }
88436
88437   jresult = (void *)result;
88438   return jresult;
88439 }
88440
88441
88442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
88443   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
88444
88445   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
88446   {
88447     try {
88448       delete arg1;
88449     } catch (std::out_of_range& e) {
88450       {
88451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88452       };
88453     } catch (std::exception& e) {
88454       {
88455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88456       };
88457     } catch (Dali::DaliException e) {
88458       {
88459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88460       };
88461     } catch (...) {
88462       {
88463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88464       };
88465     }
88466   }
88467
88468 }
88469
88470
88471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
88472   void * jresult ;
88473   Dali::Toolkit::Popup *result = 0 ;
88474
88475   {
88476     try {
88477       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
88478     } catch (std::out_of_range& e) {
88479       {
88480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88481       };
88482     } catch (std::exception& e) {
88483       {
88484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88485       };
88486     } catch (Dali::DaliException e) {
88487       {
88488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88489       };
88490     } catch (...) {
88491       {
88492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88493       };
88494     }
88495   }
88496
88497   jresult = (void *)result;
88498   return jresult;
88499 }
88500
88501
88502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
88503   void * jresult ;
88504   Dali::Toolkit::Popup result;
88505
88506   {
88507     try {
88508       result = Dali::Toolkit::Popup::New();
88509     } catch (std::out_of_range& e) {
88510       {
88511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88512       };
88513     } catch (std::exception& e) {
88514       {
88515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88516       };
88517     } catch (Dali::DaliException e) {
88518       {
88519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88520       };
88521     } catch (...) {
88522       {
88523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88524       };
88525     }
88526   }
88527
88528   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88529   return jresult;
88530 }
88531
88532
88533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
88534   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88535
88536   arg1 = (Dali::Toolkit::Popup *)jarg1;
88537   {
88538     try {
88539       delete arg1;
88540     } catch (std::out_of_range& e) {
88541       {
88542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88543       };
88544     } catch (std::exception& e) {
88545       {
88546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88547       };
88548     } catch (Dali::DaliException e) {
88549       {
88550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88551       };
88552     } catch (...) {
88553       {
88554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88555       };
88556     }
88557   }
88558
88559 }
88560
88561
88562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88563   void * jresult ;
88564   Dali::Toolkit::Popup *arg1 = 0 ;
88565   Dali::Toolkit::Popup *result = 0 ;
88566
88567   arg1 = (Dali::Toolkit::Popup *)jarg1;
88568   if (!arg1) {
88569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88570     return 0;
88571   }
88572   {
88573     try {
88574       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88575     } catch (std::out_of_range& e) {
88576       {
88577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88578       };
88579     } catch (std::exception& e) {
88580       {
88581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88582       };
88583     } catch (Dali::DaliException e) {
88584       {
88585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88586       };
88587     } catch (...) {
88588       {
88589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88590       };
88591     }
88592   }
88593
88594   jresult = (void *)result;
88595   return jresult;
88596 }
88597
88598
88599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88600   void * jresult ;
88601   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88602   Dali::Toolkit::Popup *arg2 = 0 ;
88603   Dali::Toolkit::Popup *result = 0 ;
88604
88605   arg1 = (Dali::Toolkit::Popup *)jarg1;
88606   arg2 = (Dali::Toolkit::Popup *)jarg2;
88607   if (!arg2) {
88608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88609     return 0;
88610   }
88611   {
88612     try {
88613       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88614     } catch (std::out_of_range& e) {
88615       {
88616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88617       };
88618     } catch (std::exception& e) {
88619       {
88620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88621       };
88622     } catch (Dali::DaliException e) {
88623       {
88624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88625       };
88626     } catch (...) {
88627       {
88628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88629       };
88630     }
88631   }
88632
88633   jresult = (void *)result;
88634   return jresult;
88635 }
88636
88637
88638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88639   void * jresult ;
88640   Dali::BaseHandle arg1 ;
88641   Dali::BaseHandle *argp1 ;
88642   Dali::Toolkit::Popup result;
88643
88644   argp1 = (Dali::BaseHandle *)jarg1;
88645   if (!argp1) {
88646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88647     return 0;
88648   }
88649   arg1 = *argp1;
88650   {
88651     try {
88652       result = Dali::Toolkit::Popup::DownCast(arg1);
88653     } catch (std::out_of_range& e) {
88654       {
88655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88656       };
88657     } catch (std::exception& e) {
88658       {
88659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88660       };
88661     } catch (Dali::DaliException e) {
88662       {
88663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88664       };
88665     } catch (...) {
88666       {
88667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88668       };
88669     }
88670   }
88671
88672   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88673   return jresult;
88674 }
88675
88676
88677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88678   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88679   Dali::Actor arg2 ;
88680   Dali::Actor *argp2 ;
88681
88682   arg1 = (Dali::Toolkit::Popup *)jarg1;
88683   argp2 = (Dali::Actor *)jarg2;
88684   if (!argp2) {
88685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88686     return ;
88687   }
88688   arg2 = *argp2;
88689   {
88690     try {
88691       (arg1)->SetTitle(arg2);
88692     } catch (std::out_of_range& e) {
88693       {
88694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88695       };
88696     } catch (std::exception& e) {
88697       {
88698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88699       };
88700     } catch (Dali::DaliException e) {
88701       {
88702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88703       };
88704     } catch (...) {
88705       {
88706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88707       };
88708     }
88709   }
88710
88711 }
88712
88713
88714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88715   void * jresult ;
88716   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88717   Dali::Actor result;
88718
88719   arg1 = (Dali::Toolkit::Popup *)jarg1;
88720   {
88721     try {
88722       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88723     } catch (std::out_of_range& e) {
88724       {
88725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88726       };
88727     } catch (std::exception& e) {
88728       {
88729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88730       };
88731     } catch (Dali::DaliException e) {
88732       {
88733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88734       };
88735     } catch (...) {
88736       {
88737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88738       };
88739     }
88740   }
88741
88742   jresult = new Dali::Actor((const Dali::Actor &)result);
88743   return jresult;
88744 }
88745
88746
88747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88748   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88749   Dali::Actor arg2 ;
88750   Dali::Actor *argp2 ;
88751
88752   arg1 = (Dali::Toolkit::Popup *)jarg1;
88753   argp2 = (Dali::Actor *)jarg2;
88754   if (!argp2) {
88755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88756     return ;
88757   }
88758   arg2 = *argp2;
88759   {
88760     try {
88761       (arg1)->SetContent(arg2);
88762     } catch (std::out_of_range& e) {
88763       {
88764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88765       };
88766     } catch (std::exception& e) {
88767       {
88768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88769       };
88770     } catch (Dali::DaliException e) {
88771       {
88772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88773       };
88774     } catch (...) {
88775       {
88776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88777       };
88778     }
88779   }
88780
88781 }
88782
88783
88784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88785   void * jresult ;
88786   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88787   Dali::Actor result;
88788
88789   arg1 = (Dali::Toolkit::Popup *)jarg1;
88790   {
88791     try {
88792       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88793     } catch (std::out_of_range& e) {
88794       {
88795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88796       };
88797     } catch (std::exception& e) {
88798       {
88799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88800       };
88801     } catch (Dali::DaliException e) {
88802       {
88803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88804       };
88805     } catch (...) {
88806       {
88807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88808       };
88809     }
88810   }
88811
88812   jresult = new Dali::Actor((const Dali::Actor &)result);
88813   return jresult;
88814 }
88815
88816
88817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88818   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88819   Dali::Actor arg2 ;
88820   Dali::Actor *argp2 ;
88821
88822   arg1 = (Dali::Toolkit::Popup *)jarg1;
88823   argp2 = (Dali::Actor *)jarg2;
88824   if (!argp2) {
88825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88826     return ;
88827   }
88828   arg2 = *argp2;
88829   {
88830     try {
88831       (arg1)->SetFooter(arg2);
88832     } catch (std::out_of_range& e) {
88833       {
88834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88835       };
88836     } catch (std::exception& e) {
88837       {
88838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88839       };
88840     } catch (Dali::DaliException e) {
88841       {
88842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88843       };
88844     } catch (...) {
88845       {
88846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88847       };
88848     }
88849   }
88850
88851 }
88852
88853
88854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88855   void * jresult ;
88856   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88857   Dali::Actor result;
88858
88859   arg1 = (Dali::Toolkit::Popup *)jarg1;
88860   {
88861     try {
88862       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88863     } catch (std::out_of_range& e) {
88864       {
88865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88866       };
88867     } catch (std::exception& e) {
88868       {
88869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88870       };
88871     } catch (Dali::DaliException e) {
88872       {
88873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88874       };
88875     } catch (...) {
88876       {
88877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88878       };
88879     }
88880   }
88881
88882   jresult = new Dali::Actor((const Dali::Actor &)result);
88883   return jresult;
88884 }
88885
88886
88887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88888   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88889   Dali::Toolkit::Popup::DisplayState arg2 ;
88890
88891   arg1 = (Dali::Toolkit::Popup *)jarg1;
88892   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88893   {
88894     try {
88895       (arg1)->SetDisplayState(arg2);
88896     } catch (std::out_of_range& e) {
88897       {
88898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88899       };
88900     } catch (std::exception& e) {
88901       {
88902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88903       };
88904     } catch (Dali::DaliException e) {
88905       {
88906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88907       };
88908     } catch (...) {
88909       {
88910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88911       };
88912     }
88913   }
88914
88915 }
88916
88917
88918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88919   int jresult ;
88920   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88921   Dali::Toolkit::Popup::DisplayState result;
88922
88923   arg1 = (Dali::Toolkit::Popup *)jarg1;
88924   {
88925     try {
88926       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88927     } catch (std::out_of_range& e) {
88928       {
88929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88930       };
88931     } catch (std::exception& e) {
88932       {
88933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88934       };
88935     } catch (Dali::DaliException e) {
88936       {
88937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88938       };
88939     } catch (...) {
88940       {
88941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88942       };
88943     }
88944   }
88945
88946   jresult = (int)result;
88947   return jresult;
88948 }
88949
88950
88951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88952   void * jresult ;
88953   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88954   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88955
88956   arg1 = (Dali::Toolkit::Popup *)jarg1;
88957   {
88958     try {
88959       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88960     } catch (std::out_of_range& e) {
88961       {
88962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88963       };
88964     } catch (std::exception& e) {
88965       {
88966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88967       };
88968     } catch (Dali::DaliException e) {
88969       {
88970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88971       };
88972     } catch (...) {
88973       {
88974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88975       };
88976     }
88977   }
88978
88979   jresult = (void *)result;
88980   return jresult;
88981 }
88982
88983
88984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88985   void * jresult ;
88986   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88987   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88988
88989   arg1 = (Dali::Toolkit::Popup *)jarg1;
88990   {
88991     try {
88992       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88993     } catch (std::out_of_range& e) {
88994       {
88995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88996       };
88997     } catch (std::exception& e) {
88998       {
88999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89000       };
89001     } catch (Dali::DaliException e) {
89002       {
89003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89004       };
89005     } catch (...) {
89006       {
89007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89008       };
89009     }
89010   }
89011
89012   jresult = (void *)result;
89013   return jresult;
89014 }
89015
89016
89017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
89018   void * jresult ;
89019   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89020   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89021
89022   arg1 = (Dali::Toolkit::Popup *)jarg1;
89023   {
89024     try {
89025       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
89026     } catch (std::out_of_range& e) {
89027       {
89028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89029       };
89030     } catch (std::exception& e) {
89031       {
89032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89033       };
89034     } catch (Dali::DaliException e) {
89035       {
89036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89037       };
89038     } catch (...) {
89039       {
89040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89041       };
89042     }
89043   }
89044
89045   jresult = (void *)result;
89046   return jresult;
89047 }
89048
89049
89050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
89051   void * jresult ;
89052   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89053   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89054
89055   arg1 = (Dali::Toolkit::Popup *)jarg1;
89056   {
89057     try {
89058       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
89059     } catch (std::out_of_range& e) {
89060       {
89061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89062       };
89063     } catch (std::exception& e) {
89064       {
89065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89066       };
89067     } catch (Dali::DaliException e) {
89068       {
89069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89070       };
89071     } catch (...) {
89072       {
89073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89074       };
89075     }
89076   }
89077
89078   jresult = (void *)result;
89079   return jresult;
89080 }
89081
89082
89083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
89084   void * jresult ;
89085   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89086   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89087
89088   arg1 = (Dali::Toolkit::Popup *)jarg1;
89089   {
89090     try {
89091       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
89092     } catch (std::out_of_range& e) {
89093       {
89094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89095       };
89096     } catch (std::exception& e) {
89097       {
89098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89099       };
89100     } catch (Dali::DaliException e) {
89101       {
89102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89103       };
89104     } catch (...) {
89105       {
89106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89107       };
89108     }
89109   }
89110
89111   jresult = (void *)result;
89112   return jresult;
89113 }
89114
89115
89116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
89117   int jresult ;
89118   int result;
89119
89120   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
89121   jresult = (int)result;
89122   return jresult;
89123 }
89124
89125
89126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
89127   int jresult ;
89128   int result;
89129
89130   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
89131   jresult = (int)result;
89132   return jresult;
89133 }
89134
89135
89136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
89137   int jresult ;
89138   int result;
89139
89140   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
89141   jresult = (int)result;
89142   return jresult;
89143 }
89144
89145
89146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
89147   int jresult ;
89148   int result;
89149
89150   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
89151   jresult = (int)result;
89152   return jresult;
89153 }
89154
89155
89156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
89157   int jresult ;
89158   int result;
89159
89160   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
89161   jresult = (int)result;
89162   return jresult;
89163 }
89164
89165
89166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
89167   int jresult ;
89168   int result;
89169
89170   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
89171   jresult = (int)result;
89172   return jresult;
89173 }
89174
89175
89176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
89177   int jresult ;
89178   int result;
89179
89180   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
89181   jresult = (int)result;
89182   return jresult;
89183 }
89184
89185
89186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
89187   int jresult ;
89188   int result;
89189
89190   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
89191   jresult = (int)result;
89192   return jresult;
89193 }
89194
89195
89196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
89197   int jresult ;
89198   int result;
89199
89200   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
89201   jresult = (int)result;
89202   return jresult;
89203 }
89204
89205
89206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
89207   void * jresult ;
89208   Dali::Toolkit::ProgressBar::Property *result = 0 ;
89209
89210   {
89211     try {
89212       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
89213     } catch (std::out_of_range& e) {
89214       {
89215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89216       };
89217     } catch (std::exception& e) {
89218       {
89219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89220       };
89221     } catch (Dali::DaliException e) {
89222       {
89223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89224       };
89225     } catch (...) {
89226       {
89227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89228       };
89229     }
89230   }
89231
89232   jresult = (void *)result;
89233   return jresult;
89234 }
89235
89236
89237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
89238   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
89239
89240   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
89241   {
89242     try {
89243       delete arg1;
89244     } catch (std::out_of_range& e) {
89245       {
89246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89247       };
89248     } catch (std::exception& e) {
89249       {
89250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89251       };
89252     } catch (Dali::DaliException e) {
89253       {
89254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89255       };
89256     } catch (...) {
89257       {
89258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89259       };
89260     }
89261   }
89262
89263 }
89264
89265
89266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
89267   void * jresult ;
89268   Dali::Toolkit::ProgressBar result;
89269
89270   {
89271     try {
89272       result = Dali::Toolkit::ProgressBar::New();
89273     } catch (std::out_of_range& e) {
89274       {
89275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89276       };
89277     } catch (std::exception& e) {
89278       {
89279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89280       };
89281     } catch (Dali::DaliException e) {
89282       {
89283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89284       };
89285     } catch (...) {
89286       {
89287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89288       };
89289     }
89290   }
89291
89292   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89293   return jresult;
89294 }
89295
89296
89297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
89298   void * jresult ;
89299   Dali::Toolkit::ProgressBar *result = 0 ;
89300
89301   {
89302     try {
89303       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
89304     } catch (std::out_of_range& e) {
89305       {
89306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89307       };
89308     } catch (std::exception& e) {
89309       {
89310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89311       };
89312     } catch (Dali::DaliException e) {
89313       {
89314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89315       };
89316     } catch (...) {
89317       {
89318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89319       };
89320     }
89321   }
89322
89323   jresult = (void *)result;
89324   return jresult;
89325 }
89326
89327
89328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
89329   void * jresult ;
89330   Dali::Toolkit::ProgressBar *arg1 = 0 ;
89331   Dali::Toolkit::ProgressBar *result = 0 ;
89332
89333   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89334   if (!arg1) {
89335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89336     return 0;
89337   }
89338   {
89339     try {
89340       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
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_ProgressBar_Assign(void * jarg1, void * jarg2) {
89366   void * jresult ;
89367   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89368   Dali::Toolkit::ProgressBar *arg2 = 0 ;
89369   Dali::Toolkit::ProgressBar *result = 0 ;
89370
89371   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89372   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
89373   if (!arg2) {
89374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89375     return 0;
89376   }
89377   {
89378     try {
89379       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
89380     } catch (std::out_of_range& e) {
89381       {
89382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89383       };
89384     } catch (std::exception& e) {
89385       {
89386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89387       };
89388     } catch (Dali::DaliException e) {
89389       {
89390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89391       };
89392     } catch (...) {
89393       {
89394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89395       };
89396     }
89397   }
89398
89399   jresult = (void *)result;
89400   return jresult;
89401 }
89402
89403
89404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
89405   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89406
89407   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89408   {
89409     try {
89410       delete arg1;
89411     } catch (std::out_of_range& e) {
89412       {
89413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89414       };
89415     } catch (std::exception& e) {
89416       {
89417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89418       };
89419     } catch (Dali::DaliException e) {
89420       {
89421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89422       };
89423     } catch (...) {
89424       {
89425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89426       };
89427     }
89428   }
89429
89430 }
89431
89432
89433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
89434   void * jresult ;
89435   Dali::BaseHandle arg1 ;
89436   Dali::BaseHandle *argp1 ;
89437   Dali::Toolkit::ProgressBar result;
89438
89439   argp1 = (Dali::BaseHandle *)jarg1;
89440   if (!argp1) {
89441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89442     return 0;
89443   }
89444   arg1 = *argp1;
89445   {
89446     try {
89447       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
89448     } catch (std::out_of_range& e) {
89449       {
89450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89451       };
89452     } catch (std::exception& e) {
89453       {
89454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89455       };
89456     } catch (Dali::DaliException e) {
89457       {
89458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89459       };
89460     } catch (...) {
89461       {
89462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89463       };
89464     }
89465   }
89466
89467   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89468   return jresult;
89469 }
89470
89471
89472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
89473   void * jresult ;
89474   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89475   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
89476
89477   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89478   {
89479     try {
89480       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
89481     } catch (std::out_of_range& e) {
89482       {
89483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89484       };
89485     } catch (std::exception& e) {
89486       {
89487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89488       };
89489     } catch (Dali::DaliException e) {
89490       {
89491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89492       };
89493     } catch (...) {
89494       {
89495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89496       };
89497     }
89498   }
89499
89500   jresult = (void *)result;
89501   return jresult;
89502 }
89503
89504
89505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
89506   void * jresult ;
89507   Dali::Toolkit::GaussianBlurView *result = 0 ;
89508
89509   {
89510     try {
89511       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
89512     } catch (std::out_of_range& e) {
89513       {
89514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89515       };
89516     } catch (std::exception& e) {
89517       {
89518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89519       };
89520     } catch (Dali::DaliException e) {
89521       {
89522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89523       };
89524     } catch (...) {
89525       {
89526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89527       };
89528     }
89529   }
89530
89531   jresult = (void *)result;
89532   return jresult;
89533 }
89534
89535
89536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
89537   void * jresult ;
89538   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
89539   Dali::Toolkit::GaussianBlurView *result = 0 ;
89540
89541   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89542   if (!arg1) {
89543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89544     return 0;
89545   }
89546   {
89547     try {
89548       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
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_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89574   void * jresult ;
89575   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89576   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89577   Dali::Toolkit::GaussianBlurView *result = 0 ;
89578
89579   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89580   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89581   if (!arg2) {
89582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89583     return 0;
89584   }
89585   {
89586     try {
89587       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89588     } catch (std::out_of_range& e) {
89589       {
89590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89591       };
89592     } catch (std::exception& e) {
89593       {
89594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89595       };
89596     } catch (Dali::DaliException e) {
89597       {
89598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89599       };
89600     } catch (...) {
89601       {
89602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89603       };
89604     }
89605   }
89606
89607   jresult = (void *)result;
89608   return jresult;
89609 }
89610
89611
89612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89613   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89614
89615   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89616   {
89617     try {
89618       delete arg1;
89619     } catch (std::out_of_range& e) {
89620       {
89621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89622       };
89623     } catch (std::exception& e) {
89624       {
89625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89626       };
89627     } catch (Dali::DaliException e) {
89628       {
89629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89630       };
89631     } catch (...) {
89632       {
89633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89634       };
89635     }
89636   }
89637
89638 }
89639
89640
89641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89642   void * jresult ;
89643   Dali::BaseHandle arg1 ;
89644   Dali::BaseHandle *argp1 ;
89645   Dali::Toolkit::GaussianBlurView result;
89646
89647   argp1 = (Dali::BaseHandle *)jarg1;
89648   if (!argp1) {
89649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89650     return 0;
89651   }
89652   arg1 = *argp1;
89653   {
89654     try {
89655       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89656     } catch (std::out_of_range& e) {
89657       {
89658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89659       };
89660     } catch (std::exception& e) {
89661       {
89662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89663       };
89664     } catch (Dali::DaliException e) {
89665       {
89666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89667       };
89668     } catch (...) {
89669       {
89670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89671       };
89672     }
89673   }
89674
89675   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89676   return jresult;
89677 }
89678
89679
89680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89681   void * jresult ;
89682   Dali::Toolkit::GaussianBlurView result;
89683
89684   {
89685     try {
89686       result = Dali::Toolkit::GaussianBlurView::New();
89687     } catch (std::out_of_range& e) {
89688       {
89689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89690       };
89691     } catch (std::exception& e) {
89692       {
89693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89694       };
89695     } catch (Dali::DaliException e) {
89696       {
89697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89698       };
89699     } catch (...) {
89700       {
89701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89702       };
89703     }
89704   }
89705
89706   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89707   return jresult;
89708 }
89709
89710
89711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89712   void * jresult ;
89713   unsigned int arg1 ;
89714   float arg2 ;
89715   Dali::Pixel::Format arg3 ;
89716   float arg4 ;
89717   float arg5 ;
89718   bool arg6 ;
89719   Dali::Toolkit::GaussianBlurView result;
89720
89721   arg1 = (unsigned int)jarg1;
89722   arg2 = (float)jarg2;
89723   arg3 = (Dali::Pixel::Format)jarg3;
89724   arg4 = (float)jarg4;
89725   arg5 = (float)jarg5;
89726   arg6 = jarg6 ? true : false;
89727   {
89728     try {
89729       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89730     } catch (std::out_of_range& e) {
89731       {
89732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89733       };
89734     } catch (std::exception& e) {
89735       {
89736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89737       };
89738     } catch (Dali::DaliException e) {
89739       {
89740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89741       };
89742     } catch (...) {
89743       {
89744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89745       };
89746     }
89747   }
89748
89749   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89750   return jresult;
89751 }
89752
89753
89754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89755   void * jresult ;
89756   unsigned int arg1 ;
89757   float arg2 ;
89758   Dali::Pixel::Format arg3 ;
89759   float arg4 ;
89760   float arg5 ;
89761   Dali::Toolkit::GaussianBlurView result;
89762
89763   arg1 = (unsigned int)jarg1;
89764   arg2 = (float)jarg2;
89765   arg3 = (Dali::Pixel::Format)jarg3;
89766   arg4 = (float)jarg4;
89767   arg5 = (float)jarg5;
89768   {
89769     try {
89770       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89771     } catch (std::out_of_range& e) {
89772       {
89773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89774       };
89775     } catch (std::exception& e) {
89776       {
89777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89778       };
89779     } catch (Dali::DaliException e) {
89780       {
89781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89782       };
89783     } catch (...) {
89784       {
89785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89786       };
89787     }
89788   }
89789
89790   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89791   return jresult;
89792 }
89793
89794
89795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89796   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89797   Dali::Actor arg2 ;
89798   Dali::Actor *argp2 ;
89799
89800   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89801   argp2 = (Dali::Actor *)jarg2;
89802   if (!argp2) {
89803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89804     return ;
89805   }
89806   arg2 = *argp2;
89807   {
89808     try {
89809       (arg1)->Add(arg2);
89810     } catch (std::out_of_range& e) {
89811       {
89812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89813       };
89814     } catch (std::exception& e) {
89815       {
89816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89817       };
89818     } catch (Dali::DaliException e) {
89819       {
89820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89821       };
89822     } catch (...) {
89823       {
89824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89825       };
89826     }
89827   }
89828
89829 }
89830
89831
89832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(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)->Remove(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_Activate(void * jarg1) {
89870   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89871
89872   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89873   {
89874     try {
89875       (arg1)->Activate();
89876     } catch (std::out_of_range& e) {
89877       {
89878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89879       };
89880     } catch (std::exception& e) {
89881       {
89882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89883       };
89884     } catch (Dali::DaliException e) {
89885       {
89886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89887       };
89888     } catch (...) {
89889       {
89890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89891       };
89892     }
89893   }
89894
89895 }
89896
89897
89898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89899   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89900
89901   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89902   {
89903     try {
89904       (arg1)->ActivateOnce();
89905     } catch (std::out_of_range& e) {
89906       {
89907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89908       };
89909     } catch (std::exception& e) {
89910       {
89911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89912       };
89913     } catch (Dali::DaliException e) {
89914       {
89915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89916       };
89917     } catch (...) {
89918       {
89919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89920       };
89921     }
89922   }
89923
89924 }
89925
89926
89927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89928   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89929
89930   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89931   {
89932     try {
89933       (arg1)->Deactivate();
89934     } catch (std::out_of_range& e) {
89935       {
89936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89937       };
89938     } catch (std::exception& e) {
89939       {
89940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89941       };
89942     } catch (Dali::DaliException e) {
89943       {
89944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89945       };
89946     } catch (...) {
89947       {
89948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89949       };
89950     }
89951   }
89952
89953 }
89954
89955
89956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89957   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89958   Dali::Image arg2 ;
89959   Dali::FrameBufferImage arg3 ;
89960   Dali::Image *argp2 ;
89961   Dali::FrameBufferImage *argp3 ;
89962
89963   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89964   argp2 = (Dali::Image *)jarg2;
89965   if (!argp2) {
89966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89967     return ;
89968   }
89969   arg2 = *argp2;
89970   argp3 = (Dali::FrameBufferImage *)jarg3;
89971   if (!argp3) {
89972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89973     return ;
89974   }
89975   arg3 = *argp3;
89976   {
89977     try {
89978       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89979     } catch (std::out_of_range& e) {
89980       {
89981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89982       };
89983     } catch (std::exception& e) {
89984       {
89985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89986       };
89987     } catch (Dali::DaliException e) {
89988       {
89989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89990       };
89991     } catch (...) {
89992       {
89993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89994       };
89995     }
89996   }
89997
89998 }
89999
90000
90001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
90002   int jresult ;
90003   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90004   Dali::Property::Index result;
90005
90006   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90007   {
90008     try {
90009       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
90010     } catch (std::out_of_range& e) {
90011       {
90012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90013       };
90014     } catch (std::exception& e) {
90015       {
90016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90017       };
90018     } catch (Dali::DaliException e) {
90019       {
90020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90021       };
90022     } catch (...) {
90023       {
90024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90025       };
90026     }
90027   }
90028
90029   jresult = result;
90030   return jresult;
90031 }
90032
90033
90034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
90035   void * jresult ;
90036   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90037   Dali::FrameBufferImage result;
90038
90039   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90040   {
90041     try {
90042       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
90043     } catch (std::out_of_range& e) {
90044       {
90045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90046       };
90047     } catch (std::exception& e) {
90048       {
90049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90050       };
90051     } catch (Dali::DaliException e) {
90052       {
90053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90054       };
90055     } catch (...) {
90056       {
90057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90058       };
90059     }
90060   }
90061
90062   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
90063   return jresult;
90064 }
90065
90066
90067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
90068   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90069   Dali::Vector4 *arg2 = 0 ;
90070
90071   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90072   arg2 = (Dali::Vector4 *)jarg2;
90073   if (!arg2) {
90074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
90075     return ;
90076   }
90077   {
90078     try {
90079       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
90080     } catch (std::out_of_range& e) {
90081       {
90082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90083       };
90084     } catch (std::exception& e) {
90085       {
90086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90087       };
90088     } catch (Dali::DaliException e) {
90089       {
90090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90091       };
90092     } catch (...) {
90093       {
90094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90095       };
90096     }
90097   }
90098
90099 }
90100
90101
90102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
90103   void * jresult ;
90104   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90105   Dali::Vector4 result;
90106
90107   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90108   {
90109     try {
90110       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
90111     } catch (std::out_of_range& e) {
90112       {
90113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90114       };
90115     } catch (std::exception& e) {
90116       {
90117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90118       };
90119     } catch (Dali::DaliException e) {
90120       {
90121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90122       };
90123     } catch (...) {
90124       {
90125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90126       };
90127     }
90128   }
90129
90130   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
90131   return jresult;
90132 }
90133
90134
90135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
90136   void * jresult ;
90137   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90138   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
90139
90140   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90141   {
90142     try {
90143       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
90144     } catch (std::out_of_range& e) {
90145       {
90146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90147       };
90148     } catch (std::exception& e) {
90149       {
90150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90151       };
90152     } catch (Dali::DaliException e) {
90153       {
90154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90155       };
90156     } catch (...) {
90157       {
90158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90159       };
90160     }
90161   }
90162
90163   jresult = (void *)result;
90164   return jresult;
90165 }
90166
90167
90168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
90169   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90170
90171   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90172   {
90173     try {
90174       delete arg1;
90175     } catch (std::out_of_range& e) {
90176       {
90177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90178       };
90179     } catch (std::exception& e) {
90180       {
90181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90182       };
90183     } catch (Dali::DaliException e) {
90184       {
90185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90186       };
90187     } catch (...) {
90188       {
90189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90190       };
90191     }
90192   }
90193
90194 }
90195
90196
90197 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
90198   unsigned int jresult ;
90199   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90200   unsigned int result;
90201
90202   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90203   {
90204     try {
90205       result = (unsigned int)(arg1)->GetNumberOfPages();
90206     } catch (std::out_of_range& e) {
90207       {
90208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90209       };
90210     } catch (std::exception& e) {
90211       {
90212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90213       };
90214     } catch (Dali::DaliException e) {
90215       {
90216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90217       };
90218     } catch (...) {
90219       {
90220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90221       };
90222     }
90223   }
90224
90225   jresult = result;
90226   return jresult;
90227 }
90228
90229
90230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
90231   void * jresult ;
90232   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90233   unsigned int arg2 ;
90234   Dali::Texture result;
90235
90236   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90237   arg2 = (unsigned int)jarg2;
90238   {
90239     try {
90240       result = (arg1)->NewPage(arg2);
90241     } catch (std::out_of_range& e) {
90242       {
90243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90244       };
90245     } catch (std::exception& e) {
90246       {
90247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90248       };
90249     } catch (Dali::DaliException e) {
90250       {
90251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90252       };
90253     } catch (...) {
90254       {
90255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90256       };
90257     }
90258   }
90259
90260   jresult = new Dali::Texture((const Dali::Texture &)result);
90261   return jresult;
90262 }
90263
90264
90265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
90266   int jresult ;
90267   int result;
90268
90269   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
90270   jresult = (int)result;
90271   return jresult;
90272 }
90273
90274
90275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
90276   int jresult ;
90277   int result;
90278
90279   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
90280   jresult = (int)result;
90281   return jresult;
90282 }
90283
90284
90285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
90286   int jresult ;
90287   int result;
90288
90289   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
90290   jresult = (int)result;
90291   return jresult;
90292 }
90293
90294
90295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
90296   void * jresult ;
90297   Dali::Toolkit::PageTurnView::Property *result = 0 ;
90298
90299   {
90300     try {
90301       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
90302     } catch (std::out_of_range& e) {
90303       {
90304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90305       };
90306     } catch (std::exception& e) {
90307       {
90308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90309       };
90310     } catch (Dali::DaliException e) {
90311       {
90312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90313       };
90314     } catch (...) {
90315       {
90316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90317       };
90318     }
90319   }
90320
90321   jresult = (void *)result;
90322   return jresult;
90323 }
90324
90325
90326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
90327   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
90328
90329   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
90330   {
90331     try {
90332       delete arg1;
90333     } catch (std::out_of_range& e) {
90334       {
90335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90336       };
90337     } catch (std::exception& e) {
90338       {
90339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90340       };
90341     } catch (Dali::DaliException e) {
90342       {
90343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90344       };
90345     } catch (...) {
90346       {
90347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90348       };
90349     }
90350   }
90351
90352 }
90353
90354
90355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
90356   void * jresult ;
90357   Dali::Toolkit::PageTurnView *result = 0 ;
90358
90359   {
90360     try {
90361       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
90362     } catch (std::out_of_range& e) {
90363       {
90364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90365       };
90366     } catch (std::exception& e) {
90367       {
90368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90369       };
90370     } catch (Dali::DaliException e) {
90371       {
90372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90373       };
90374     } catch (...) {
90375       {
90376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90377       };
90378     }
90379   }
90380
90381   jresult = (void *)result;
90382   return jresult;
90383 }
90384
90385
90386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
90387   void * jresult ;
90388   Dali::Toolkit::PageTurnView *arg1 = 0 ;
90389   Dali::Toolkit::PageTurnView *result = 0 ;
90390
90391   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90392   if (!arg1) {
90393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90394     return 0;
90395   }
90396   {
90397     try {
90398       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
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_PageTurnView_Assign(void * jarg1, void * jarg2) {
90424   void * jresult ;
90425   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90426   Dali::Toolkit::PageTurnView *arg2 = 0 ;
90427   Dali::Toolkit::PageTurnView *result = 0 ;
90428
90429   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90430   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
90431   if (!arg2) {
90432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90433     return 0;
90434   }
90435   {
90436     try {
90437       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
90438     } catch (std::out_of_range& e) {
90439       {
90440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90441       };
90442     } catch (std::exception& e) {
90443       {
90444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90445       };
90446     } catch (Dali::DaliException e) {
90447       {
90448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90449       };
90450     } catch (...) {
90451       {
90452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90453       };
90454     }
90455   }
90456
90457   jresult = (void *)result;
90458   return jresult;
90459 }
90460
90461
90462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
90463   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90464
90465   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90466   {
90467     try {
90468       delete arg1;
90469     } catch (std::out_of_range& e) {
90470       {
90471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90472       };
90473     } catch (std::exception& e) {
90474       {
90475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90476       };
90477     } catch (Dali::DaliException e) {
90478       {
90479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90480       };
90481     } catch (...) {
90482       {
90483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90484       };
90485     }
90486   }
90487
90488 }
90489
90490
90491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
90492   void * jresult ;
90493   Dali::BaseHandle arg1 ;
90494   Dali::BaseHandle *argp1 ;
90495   Dali::Toolkit::PageTurnView result;
90496
90497   argp1 = (Dali::BaseHandle *)jarg1;
90498   if (!argp1) {
90499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90500     return 0;
90501   }
90502   arg1 = *argp1;
90503   {
90504     try {
90505       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
90506     } catch (std::out_of_range& e) {
90507       {
90508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90509       };
90510     } catch (std::exception& e) {
90511       {
90512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90513       };
90514     } catch (Dali::DaliException e) {
90515       {
90516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90517       };
90518     } catch (...) {
90519       {
90520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90521       };
90522     }
90523   }
90524
90525   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
90526   return jresult;
90527 }
90528
90529
90530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
90531   void * jresult ;
90532   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90533   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90534
90535   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90536   {
90537     try {
90538       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
90539     } catch (std::out_of_range& e) {
90540       {
90541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90542       };
90543     } catch (std::exception& e) {
90544       {
90545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90546       };
90547     } catch (Dali::DaliException e) {
90548       {
90549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90550       };
90551     } catch (...) {
90552       {
90553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90554       };
90555     }
90556   }
90557
90558   jresult = (void *)result;
90559   return jresult;
90560 }
90561
90562
90563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90564   void * jresult ;
90565   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90566   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90567
90568   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90569   {
90570     try {
90571       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90572     } catch (std::out_of_range& e) {
90573       {
90574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90575       };
90576     } catch (std::exception& e) {
90577       {
90578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90579       };
90580     } catch (Dali::DaliException e) {
90581       {
90582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90583       };
90584     } catch (...) {
90585       {
90586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90587       };
90588     }
90589   }
90590
90591   jresult = (void *)result;
90592   return jresult;
90593 }
90594
90595
90596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90597   void * jresult ;
90598   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90599   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90600
90601   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90602   {
90603     try {
90604       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
90605     } catch (std::out_of_range& e) {
90606       {
90607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90608       };
90609     } catch (std::exception& e) {
90610       {
90611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90612       };
90613     } catch (Dali::DaliException e) {
90614       {
90615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90616       };
90617     } catch (...) {
90618       {
90619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90620       };
90621     }
90622   }
90623
90624   jresult = (void *)result;
90625   return jresult;
90626 }
90627
90628
90629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90630   void * jresult ;
90631   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90632   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90633
90634   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90635   {
90636     try {
90637       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90638     } catch (std::out_of_range& e) {
90639       {
90640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90641       };
90642     } catch (std::exception& e) {
90643       {
90644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90645       };
90646     } catch (Dali::DaliException e) {
90647       {
90648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90649       };
90650     } catch (...) {
90651       {
90652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90653       };
90654     }
90655   }
90656
90657   jresult = (void *)result;
90658   return jresult;
90659 }
90660
90661
90662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90663   void * jresult ;
90664   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90665
90666   {
90667     try {
90668       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90669     } catch (std::out_of_range& e) {
90670       {
90671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90672       };
90673     } catch (std::exception& e) {
90674       {
90675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90676       };
90677     } catch (Dali::DaliException e) {
90678       {
90679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90680       };
90681     } catch (...) {
90682       {
90683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90684       };
90685     }
90686   }
90687
90688   jresult = (void *)result;
90689   return jresult;
90690 }
90691
90692
90693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90694   void * jresult ;
90695   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90696   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90697
90698   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90699   if (!arg1) {
90700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90701     return 0;
90702   }
90703   {
90704     try {
90705       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
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_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90731   void * jresult ;
90732   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90733   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90734   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90735
90736   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90737   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90738   if (!arg2) {
90739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90740     return 0;
90741   }
90742   {
90743     try {
90744       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90745     } catch (std::out_of_range& e) {
90746       {
90747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90748       };
90749     } catch (std::exception& e) {
90750       {
90751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90752       };
90753     } catch (Dali::DaliException e) {
90754       {
90755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90756       };
90757     } catch (...) {
90758       {
90759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90760       };
90761     }
90762   }
90763
90764   jresult = (void *)result;
90765   return jresult;
90766 }
90767
90768
90769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90770   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90771
90772   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90773   {
90774     try {
90775       delete arg1;
90776     } catch (std::out_of_range& e) {
90777       {
90778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90779       };
90780     } catch (std::exception& e) {
90781       {
90782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90783       };
90784     } catch (Dali::DaliException e) {
90785       {
90786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90787       };
90788     } catch (...) {
90789       {
90790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90791       };
90792     }
90793   }
90794
90795 }
90796
90797
90798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90799   void * jresult ;
90800   Dali::Toolkit::PageFactory *arg1 = 0 ;
90801   Dali::Vector2 *arg2 = 0 ;
90802   Dali::Toolkit::PageTurnLandscapeView result;
90803
90804   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90805   if (!arg1) {
90806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90807     return 0;
90808   }
90809   arg2 = (Dali::Vector2 *)jarg2;
90810   if (!arg2) {
90811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90812     return 0;
90813   }
90814   {
90815     try {
90816       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90817     } catch (std::out_of_range& e) {
90818       {
90819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90820       };
90821     } catch (std::exception& e) {
90822       {
90823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90824       };
90825     } catch (Dali::DaliException e) {
90826       {
90827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90828       };
90829     } catch (...) {
90830       {
90831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90832       };
90833     }
90834   }
90835
90836   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90837   return jresult;
90838 }
90839
90840
90841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90842   void * jresult ;
90843   Dali::BaseHandle arg1 ;
90844   Dali::BaseHandle *argp1 ;
90845   Dali::Toolkit::PageTurnLandscapeView result;
90846
90847   argp1 = (Dali::BaseHandle *)jarg1;
90848   if (!argp1) {
90849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90850     return 0;
90851   }
90852   arg1 = *argp1;
90853   {
90854     try {
90855       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90856     } catch (std::out_of_range& e) {
90857       {
90858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90859       };
90860     } catch (std::exception& e) {
90861       {
90862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90863       };
90864     } catch (Dali::DaliException e) {
90865       {
90866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90867       };
90868     } catch (...) {
90869       {
90870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90871       };
90872     }
90873   }
90874
90875   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90876   return jresult;
90877 }
90878
90879
90880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90881   void * jresult ;
90882   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90883
90884   {
90885     try {
90886       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90887     } catch (std::out_of_range& e) {
90888       {
90889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90890       };
90891     } catch (std::exception& e) {
90892       {
90893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90894       };
90895     } catch (Dali::DaliException e) {
90896       {
90897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90898       };
90899     } catch (...) {
90900       {
90901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90902       };
90903     }
90904   }
90905
90906   jresult = (void *)result;
90907   return jresult;
90908 }
90909
90910
90911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90912   void * jresult ;
90913   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90914   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90915
90916   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90917   if (!arg1) {
90918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90919     return 0;
90920   }
90921   {
90922     try {
90923       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
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_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90949   void * jresult ;
90950   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90951   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90952   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90953
90954   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90955   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90956   if (!arg2) {
90957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90958     return 0;
90959   }
90960   {
90961     try {
90962       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90963     } catch (std::out_of_range& e) {
90964       {
90965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90966       };
90967     } catch (std::exception& e) {
90968       {
90969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90970       };
90971     } catch (Dali::DaliException e) {
90972       {
90973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90974       };
90975     } catch (...) {
90976       {
90977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90978       };
90979     }
90980   }
90981
90982   jresult = (void *)result;
90983   return jresult;
90984 }
90985
90986
90987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90988   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90989
90990   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90991   {
90992     try {
90993       delete arg1;
90994     } catch (std::out_of_range& e) {
90995       {
90996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90997       };
90998     } catch (std::exception& e) {
90999       {
91000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91001       };
91002     } catch (Dali::DaliException e) {
91003       {
91004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91005       };
91006     } catch (...) {
91007       {
91008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91009       };
91010     }
91011   }
91012
91013 }
91014
91015
91016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
91017   void * jresult ;
91018   Dali::Toolkit::PageFactory *arg1 = 0 ;
91019   Dali::Vector2 *arg2 = 0 ;
91020   Dali::Toolkit::PageTurnPortraitView result;
91021
91022   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
91023   if (!arg1) {
91024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
91025     return 0;
91026   }
91027   arg2 = (Dali::Vector2 *)jarg2;
91028   if (!arg2) {
91029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
91030     return 0;
91031   }
91032   {
91033     try {
91034       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
91035     } catch (std::out_of_range& e) {
91036       {
91037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91038       };
91039     } catch (std::exception& e) {
91040       {
91041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91042       };
91043     } catch (Dali::DaliException e) {
91044       {
91045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91046       };
91047     } catch (...) {
91048       {
91049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91050       };
91051     }
91052   }
91053
91054   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
91055   return jresult;
91056 }
91057
91058
91059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
91060   void * jresult ;
91061   Dali::BaseHandle arg1 ;
91062   Dali::BaseHandle *argp1 ;
91063   Dali::Toolkit::PageTurnPortraitView result;
91064
91065   argp1 = (Dali::BaseHandle *)jarg1;
91066   if (!argp1) {
91067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91068     return 0;
91069   }
91070   arg1 = *argp1;
91071   {
91072     try {
91073       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
91074     } catch (std::out_of_range& e) {
91075       {
91076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91077       };
91078     } catch (std::exception& e) {
91079       {
91080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91081       };
91082     } catch (Dali::DaliException e) {
91083       {
91084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91085       };
91086     } catch (...) {
91087       {
91088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91089       };
91090     }
91091   }
91092
91093   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
91094   return jresult;
91095 }
91096
91097
91098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
91099   int jresult ;
91100   int result;
91101
91102   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
91103   jresult = (int)result;
91104   return jresult;
91105 }
91106
91107
91108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
91109   int jresult ;
91110   int result;
91111
91112   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
91113   jresult = (int)result;
91114   return jresult;
91115 }
91116
91117
91118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
91119   int jresult ;
91120   int result;
91121
91122   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
91123   jresult = (int)result;
91124   return jresult;
91125 }
91126
91127
91128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
91129   void * jresult ;
91130   Dali::Toolkit::ToggleButton::Property *result = 0 ;
91131
91132   {
91133     try {
91134       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
91135     } catch (std::out_of_range& e) {
91136       {
91137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91138       };
91139     } catch (std::exception& e) {
91140       {
91141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91142       };
91143     } catch (Dali::DaliException e) {
91144       {
91145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91146       };
91147     } catch (...) {
91148       {
91149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91150       };
91151     }
91152   }
91153
91154   jresult = (void *)result;
91155   return jresult;
91156 }
91157
91158
91159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
91160   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
91161
91162   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
91163   {
91164     try {
91165       delete arg1;
91166     } catch (std::out_of_range& e) {
91167       {
91168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91169       };
91170     } catch (std::exception& e) {
91171       {
91172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91173       };
91174     } catch (Dali::DaliException e) {
91175       {
91176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91177       };
91178     } catch (...) {
91179       {
91180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91181       };
91182     }
91183   }
91184
91185 }
91186
91187
91188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
91189   void * jresult ;
91190   Dali::Toolkit::ToggleButton *result = 0 ;
91191
91192   {
91193     try {
91194       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
91195     } catch (std::out_of_range& e) {
91196       {
91197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91198       };
91199     } catch (std::exception& e) {
91200       {
91201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91202       };
91203     } catch (Dali::DaliException e) {
91204       {
91205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91206       };
91207     } catch (...) {
91208       {
91209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91210       };
91211     }
91212   }
91213
91214   jresult = (void *)result;
91215   return jresult;
91216 }
91217
91218
91219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
91220   void * jresult ;
91221   Dali::Toolkit::ToggleButton *arg1 = 0 ;
91222   Dali::Toolkit::ToggleButton *result = 0 ;
91223
91224   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91225   if (!arg1) {
91226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91227     return 0;
91228   }
91229   {
91230     try {
91231       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
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_ToggleButton_Assign(void * jarg1, void * jarg2) {
91257   void * jresult ;
91258   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91259   Dali::Toolkit::ToggleButton *arg2 = 0 ;
91260   Dali::Toolkit::ToggleButton *result = 0 ;
91261
91262   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91263   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
91264   if (!arg2) {
91265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91266     return 0;
91267   }
91268   {
91269     try {
91270       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
91271     } catch (std::out_of_range& e) {
91272       {
91273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91274       };
91275     } catch (std::exception& e) {
91276       {
91277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91278       };
91279     } catch (Dali::DaliException e) {
91280       {
91281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91282       };
91283     } catch (...) {
91284       {
91285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91286       };
91287     }
91288   }
91289
91290   jresult = (void *)result;
91291   return jresult;
91292 }
91293
91294
91295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
91296   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91297
91298   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91299   {
91300     try {
91301       delete arg1;
91302     } catch (std::out_of_range& e) {
91303       {
91304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91305       };
91306     } catch (std::exception& e) {
91307       {
91308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91309       };
91310     } catch (Dali::DaliException e) {
91311       {
91312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91313       };
91314     } catch (...) {
91315       {
91316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91317       };
91318     }
91319   }
91320
91321 }
91322
91323
91324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
91325   void * jresult ;
91326   Dali::Toolkit::ToggleButton result;
91327
91328   {
91329     try {
91330       result = Dali::Toolkit::ToggleButton::New();
91331     } catch (std::out_of_range& e) {
91332       {
91333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91334       };
91335     } catch (std::exception& e) {
91336       {
91337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91338       };
91339     } catch (Dali::DaliException e) {
91340       {
91341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91342       };
91343     } catch (...) {
91344       {
91345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91346       };
91347     }
91348   }
91349
91350   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91351   return jresult;
91352 }
91353
91354
91355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
91356   void * jresult ;
91357   Dali::BaseHandle arg1 ;
91358   Dali::BaseHandle *argp1 ;
91359   Dali::Toolkit::ToggleButton result;
91360
91361   argp1 = (Dali::BaseHandle *)jarg1;
91362   if (!argp1) {
91363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91364     return 0;
91365   }
91366   arg1 = *argp1;
91367   {
91368     try {
91369       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
91370     } catch (std::out_of_range& e) {
91371       {
91372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91373       };
91374     } catch (std::exception& e) {
91375       {
91376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91377       };
91378     } catch (Dali::DaliException e) {
91379       {
91380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91381       };
91382     } catch (...) {
91383       {
91384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91385       };
91386     }
91387   }
91388
91389   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91390   return jresult;
91391 }
91392
91393
91394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
91395   void * jresult ;
91396   Dali::Toolkit::Visual::Base *result = 0 ;
91397
91398   {
91399     try {
91400       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
91401     } catch (std::out_of_range& e) {
91402       {
91403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91404       };
91405     } catch (std::exception& e) {
91406       {
91407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91408       };
91409     } catch (Dali::DaliException e) {
91410       {
91411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91412       };
91413     } catch (...) {
91414       {
91415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91416       };
91417     }
91418   }
91419
91420   jresult = (void *)result;
91421   return jresult;
91422 }
91423
91424
91425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
91426   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91427
91428   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91429   {
91430     try {
91431       delete arg1;
91432     } catch (std::out_of_range& e) {
91433       {
91434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91435       };
91436     } catch (std::exception& e) {
91437       {
91438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91439       };
91440     } catch (Dali::DaliException e) {
91441       {
91442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91443       };
91444     } catch (...) {
91445       {
91446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91447       };
91448     }
91449   }
91450
91451 }
91452
91453
91454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
91455   void * jresult ;
91456   Dali::Toolkit::Visual::Base *arg1 = 0 ;
91457   Dali::Toolkit::Visual::Base *result = 0 ;
91458
91459   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91460   if (!arg1) {
91461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91462     return 0;
91463   }
91464   {
91465     try {
91466       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
91467     } catch (std::out_of_range& e) {
91468       {
91469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91470       };
91471     } catch (std::exception& e) {
91472       {
91473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91474       };
91475     } catch (Dali::DaliException e) {
91476       {
91477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91478       };
91479     } catch (...) {
91480       {
91481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91482       };
91483     }
91484   }
91485
91486   jresult = (void *)result;
91487   return jresult;
91488 }
91489
91490
91491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
91492   void * jresult ;
91493   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91494   Dali::Toolkit::Visual::Base *arg2 = 0 ;
91495   Dali::Toolkit::Visual::Base *result = 0 ;
91496
91497   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91498   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
91499   if (!arg2) {
91500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91501     return 0;
91502   }
91503   {
91504     try {
91505       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
91506     } catch (std::out_of_range& e) {
91507       {
91508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91509       };
91510     } catch (std::exception& e) {
91511       {
91512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91513       };
91514     } catch (Dali::DaliException e) {
91515       {
91516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91517       };
91518     } catch (...) {
91519       {
91520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91521       };
91522     }
91523   }
91524
91525   jresult = (void *)result;
91526   return jresult;
91527 }
91528
91529
91530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
91531   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91532   std::string *arg2 = 0 ;
91533
91534   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91535   if (!jarg2) {
91536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91537     return ;
91538   }
91539   std::string arg2_str(jarg2);
91540   arg2 = &arg2_str;
91541   {
91542     try {
91543       (arg1)->SetName((std::string const &)*arg2);
91544     } catch (std::out_of_range& e) {
91545       {
91546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91547       };
91548     } catch (std::exception& e) {
91549       {
91550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91551       };
91552     } catch (Dali::DaliException e) {
91553       {
91554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91555       };
91556     } catch (...) {
91557       {
91558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91559       };
91560     }
91561   }
91562
91563
91564   //argout typemap for const std::string&
91565
91566 }
91567
91568
91569 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91570   char * jresult ;
91571   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91572   std::string *result = 0 ;
91573
91574   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91575   {
91576     try {
91577       result = (std::string *) &(arg1)->GetName();
91578     } catch (std::out_of_range& e) {
91579       {
91580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91581       };
91582     } catch (std::exception& e) {
91583       {
91584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91585       };
91586     } catch (Dali::DaliException e) {
91587       {
91588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91589       };
91590     } catch (...) {
91591       {
91592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91593       };
91594     }
91595   }
91596
91597   jresult = SWIG_csharp_string_callback(result->c_str());
91598   return jresult;
91599 }
91600
91601
91602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91603   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91604   Dali::Property::Map *arg2 = 0 ;
91605   Dali::Size arg3 ;
91606   Dali::Size *argp3 ;
91607
91608   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91609   arg2 = (Dali::Property::Map *)jarg2;
91610   if (!arg2) {
91611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91612     return ;
91613   }
91614   argp3 = (Dali::Size *)jarg3;
91615   if (!argp3) {
91616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91617     return ;
91618   }
91619   arg3 = *argp3;
91620   {
91621     try {
91622       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91623     } catch (std::out_of_range& e) {
91624       {
91625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91626       };
91627     } catch (std::exception& e) {
91628       {
91629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91630       };
91631     } catch (Dali::DaliException e) {
91632       {
91633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91634       };
91635     } catch (...) {
91636       {
91637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91638       };
91639     }
91640   }
91641
91642 }
91643
91644
91645 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91646   float jresult ;
91647   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91648   float arg2 ;
91649   float result;
91650
91651   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91652   arg2 = (float)jarg2;
91653   {
91654     try {
91655       result = (float)(arg1)->GetHeightForWidth(arg2);
91656     } catch (std::out_of_range& e) {
91657       {
91658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91659       };
91660     } catch (std::exception& e) {
91661       {
91662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91663       };
91664     } catch (Dali::DaliException e) {
91665       {
91666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91667       };
91668     } catch (...) {
91669       {
91670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91671       };
91672     }
91673   }
91674
91675   jresult = result;
91676   return jresult;
91677 }
91678
91679
91680 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91681   float jresult ;
91682   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91683   float arg2 ;
91684   float result;
91685
91686   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91687   arg2 = (float)jarg2;
91688   {
91689     try {
91690       result = (float)(arg1)->GetWidthForHeight(arg2);
91691     } catch (std::out_of_range& e) {
91692       {
91693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91694       };
91695     } catch (std::exception& e) {
91696       {
91697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91698       };
91699     } catch (Dali::DaliException e) {
91700       {
91701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91702       };
91703     } catch (...) {
91704       {
91705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91706       };
91707     }
91708   }
91709
91710   jresult = result;
91711   return jresult;
91712 }
91713
91714
91715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91716   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91717   Dali::Vector2 *arg2 = 0 ;
91718
91719   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91720   arg2 = (Dali::Vector2 *)jarg2;
91721   if (!arg2) {
91722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91723     return ;
91724   }
91725   {
91726     try {
91727       (arg1)->GetNaturalSize(*arg2);
91728     } catch (std::out_of_range& e) {
91729       {
91730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91731       };
91732     } catch (std::exception& e) {
91733       {
91734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91735       };
91736     } catch (Dali::DaliException e) {
91737       {
91738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91739       };
91740     } catch (...) {
91741       {
91742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91743       };
91744     }
91745   }
91746
91747 }
91748
91749
91750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91751   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91752   float arg2 ;
91753
91754   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91755   arg2 = (int)jarg2;
91756   {
91757     try {
91758       (arg1)->SetDepthIndex(arg2);
91759     } catch (std::out_of_range& e) {
91760       {
91761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91762       };
91763     } catch (std::exception& e) {
91764       {
91765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91766       };
91767     } catch (Dali::DaliException e) {
91768       {
91769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91770       };
91771     } catch (...) {
91772       {
91773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91774       };
91775     }
91776   }
91777
91778 }
91779
91780
91781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91782   int jresult ;
91783   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91784   int result;
91785
91786   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91787   {
91788     try {
91789       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91790     } catch (std::out_of_range& e) {
91791       {
91792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91793       };
91794     } catch (std::exception& e) {
91795       {
91796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91797       };
91798     } catch (Dali::DaliException e) {
91799       {
91800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91801       };
91802     } catch (...) {
91803       {
91804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91805       };
91806     }
91807   }
91808
91809   jresult = result;
91810   return jresult;
91811 }
91812
91813
91814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91815   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91816   Dali::Property::Map *arg2 = 0 ;
91817
91818   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91819   arg2 = (Dali::Property::Map *)jarg2;
91820   if (!arg2) {
91821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91822     return ;
91823   }
91824   {
91825     try {
91826       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91827     } catch (std::out_of_range& e) {
91828       {
91829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91830       };
91831     } catch (std::exception& e) {
91832       {
91833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91834       };
91835     } catch (Dali::DaliException e) {
91836       {
91837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91838       };
91839     } catch (...) {
91840       {
91841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91842       };
91843     }
91844   }
91845
91846 }
91847
91848
91849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
91850   void * jresult ;
91851   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
91852   Dali::Toolkit::Visual::Base *result = 0 ;
91853
91854   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
91855   {
91856     try {
91857       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
91858     } catch (std::out_of_range& e) {
91859       {
91860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91861       };
91862     } catch (std::exception& e) {
91863       {
91864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91865       };
91866     } catch (Dali::DaliException e) {
91867       {
91868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91869       };
91870     } catch (...) {
91871       {
91872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91873       };
91874     }
91875   }
91876
91877   jresult = (void *)result;
91878   return jresult;
91879 }
91880
91881
91882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91883   void * jresult ;
91884   Dali::Toolkit::VisualFactory result;
91885
91886   {
91887     try {
91888       result = Dali::Toolkit::VisualFactory::Get();
91889     } catch (std::out_of_range& e) {
91890       {
91891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91892       };
91893     } catch (std::exception& e) {
91894       {
91895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91896       };
91897     } catch (Dali::DaliException e) {
91898       {
91899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91900       };
91901     } catch (...) {
91902       {
91903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91904       };
91905     }
91906   }
91907
91908   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91909   return jresult;
91910 }
91911
91912
91913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91914   void * jresult ;
91915   Dali::Toolkit::VisualFactory *result = 0 ;
91916
91917   {
91918     try {
91919       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91920     } catch (std::out_of_range& e) {
91921       {
91922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91923       };
91924     } catch (std::exception& e) {
91925       {
91926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91927       };
91928     } catch (Dali::DaliException e) {
91929       {
91930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91931       };
91932     } catch (...) {
91933       {
91934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91935       };
91936     }
91937   }
91938
91939   jresult = (void *)result;
91940   return jresult;
91941 }
91942
91943
91944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91945   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91946
91947   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91948   {
91949     try {
91950       delete arg1;
91951     } catch (std::out_of_range& e) {
91952       {
91953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91954       };
91955     } catch (std::exception& e) {
91956       {
91957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91958       };
91959     } catch (Dali::DaliException e) {
91960       {
91961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91962       };
91963     } catch (...) {
91964       {
91965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91966       };
91967     }
91968   }
91969
91970 }
91971
91972
91973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91974   void * jresult ;
91975   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91976   Dali::Toolkit::VisualFactory *result = 0 ;
91977
91978   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91979   if (!arg1) {
91980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91981     return 0;
91982   }
91983   {
91984     try {
91985       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91986     } catch (std::out_of_range& e) {
91987       {
91988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91989       };
91990     } catch (std::exception& e) {
91991       {
91992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91993       };
91994     } catch (Dali::DaliException e) {
91995       {
91996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91997       };
91998     } catch (...) {
91999       {
92000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92001       };
92002     }
92003   }
92004
92005   jresult = (void *)result;
92006   return jresult;
92007 }
92008
92009
92010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
92011   void * jresult ;
92012   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92013   Dali::Toolkit::VisualFactory *arg2 = 0 ;
92014   Dali::Toolkit::VisualFactory *result = 0 ;
92015
92016   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92017   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
92018   if (!arg2) {
92019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
92020     return 0;
92021   }
92022   {
92023     try {
92024       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
92025     } catch (std::out_of_range& e) {
92026       {
92027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92028       };
92029     } catch (std::exception& e) {
92030       {
92031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92032       };
92033     } catch (Dali::DaliException e) {
92034       {
92035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92036       };
92037     } catch (...) {
92038       {
92039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92040       };
92041     }
92042   }
92043
92044   jresult = (void *)result;
92045   return jresult;
92046 }
92047
92048
92049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
92050   void * jresult ;
92051   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92052   Dali::Property::Map *arg2 = 0 ;
92053   Dali::Toolkit::Visual::Base result;
92054
92055   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92056   arg2 = (Dali::Property::Map *)jarg2;
92057   if (!arg2) {
92058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
92059     return 0;
92060   }
92061   {
92062     try {
92063       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
92064     } catch (std::out_of_range& e) {
92065       {
92066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92067       };
92068     } catch (std::exception& e) {
92069       {
92070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92071       };
92072     } catch (Dali::DaliException e) {
92073       {
92074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92075       };
92076     } catch (...) {
92077       {
92078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92079       };
92080     }
92081   }
92082
92083   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92084   return jresult;
92085 }
92086
92087
92088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
92089   void * jresult ;
92090   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92091   Dali::Image *arg2 = 0 ;
92092   Dali::Toolkit::Visual::Base result;
92093
92094   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92095   arg2 = (Dali::Image *)jarg2;
92096   if (!arg2) {
92097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
92098     return 0;
92099   }
92100   {
92101     try {
92102       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
92103     } catch (std::out_of_range& e) {
92104       {
92105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92106       };
92107     } catch (std::exception& e) {
92108       {
92109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92110       };
92111     } catch (Dali::DaliException e) {
92112       {
92113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92114       };
92115     } catch (...) {
92116       {
92117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92118       };
92119     }
92120   }
92121
92122   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92123   return jresult;
92124 }
92125
92126
92127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
92128   void * jresult ;
92129   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92130   std::string *arg2 = 0 ;
92131   Dali::ImageDimensions arg3 ;
92132   Dali::ImageDimensions *argp3 ;
92133   Dali::Toolkit::Visual::Base result;
92134
92135   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92136   if (!jarg2) {
92137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92138     return 0;
92139   }
92140   std::string arg2_str(jarg2);
92141   arg2 = &arg2_str;
92142   argp3 = (Dali::ImageDimensions *)jarg3;
92143   if (!argp3) {
92144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92145     return 0;
92146   }
92147   arg3 = *argp3;
92148   {
92149     try {
92150       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
92151     } catch (std::out_of_range& e) {
92152       {
92153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92154       };
92155     } catch (std::exception& e) {
92156       {
92157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92158       };
92159     } catch (Dali::DaliException e) {
92160       {
92161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92162       };
92163     } catch (...) {
92164       {
92165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92166       };
92167     }
92168   }
92169
92170   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92171
92172   //argout typemap for const std::string&
92173
92174   return jresult;
92175 }
92176
92177
92178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
92179   void * jresult ;
92180   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92181
92182   {
92183     try {
92184       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
92185     } catch (std::out_of_range& e) {
92186       {
92187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92188       };
92189     } catch (std::exception& e) {
92190       {
92191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92192       };
92193     } catch (Dali::DaliException e) {
92194       {
92195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92196       };
92197     } catch (...) {
92198       {
92199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92200       };
92201     }
92202   }
92203
92204   jresult = (void *)result;
92205   return jresult;
92206 }
92207
92208
92209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
92210   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92211
92212   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92213   {
92214     try {
92215       delete arg1;
92216     } catch (std::out_of_range& e) {
92217       {
92218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92219       };
92220     } catch (std::exception& e) {
92221       {
92222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92223       };
92224     } catch (Dali::DaliException e) {
92225       {
92226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92227       };
92228     } catch (...) {
92229       {
92230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92231       };
92232     }
92233   }
92234
92235 }
92236
92237
92238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
92239   void * jresult ;
92240   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
92241   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92242
92243   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92244   if (!arg1) {
92245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92246     return 0;
92247   }
92248   {
92249     try {
92250       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
92251     } catch (std::out_of_range& e) {
92252       {
92253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92254       };
92255     } catch (std::exception& e) {
92256       {
92257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92258       };
92259     } catch (Dali::DaliException e) {
92260       {
92261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92262       };
92263     } catch (...) {
92264       {
92265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92266       };
92267     }
92268   }
92269
92270   jresult = (void *)result;
92271   return jresult;
92272 }
92273
92274
92275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
92276   void * jresult ;
92277   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92278   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
92279   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92280
92281   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92282   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
92283   if (!arg2) {
92284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92285     return 0;
92286   }
92287   {
92288     try {
92289       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
92290     } catch (std::out_of_range& e) {
92291       {
92292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92293       };
92294     } catch (std::exception& e) {
92295       {
92296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92297       };
92298     } catch (Dali::DaliException e) {
92299       {
92300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92301       };
92302     } catch (...) {
92303       {
92304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92305       };
92306     }
92307   }
92308
92309   jresult = (void *)result;
92310   return jresult;
92311 }
92312
92313
92314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
92315   void * jresult ;
92316   Dali::Toolkit::AsyncImageLoader result;
92317
92318   {
92319     try {
92320       result = Dali::Toolkit::AsyncImageLoader::New();
92321     } catch (std::out_of_range& e) {
92322       {
92323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92324       };
92325     } catch (std::exception& e) {
92326       {
92327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92328       };
92329     } catch (Dali::DaliException e) {
92330       {
92331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92332       };
92333     } catch (...) {
92334       {
92335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92336       };
92337     }
92338   }
92339
92340   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92341   return jresult;
92342 }
92343
92344
92345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
92346   void * jresult ;
92347   Dali::BaseHandle arg1 ;
92348   Dali::BaseHandle *argp1 ;
92349   Dali::Toolkit::AsyncImageLoader result;
92350
92351   argp1 = (Dali::BaseHandle *)jarg1;
92352   if (!argp1) {
92353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
92354     return 0;
92355   }
92356   arg1 = *argp1;
92357   {
92358     try {
92359       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
92360     } catch (std::out_of_range& e) {
92361       {
92362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92363       };
92364     } catch (std::exception& e) {
92365       {
92366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92367       };
92368     } catch (Dali::DaliException e) {
92369       {
92370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92371       };
92372     } catch (...) {
92373       {
92374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92375       };
92376     }
92377   }
92378
92379   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92380   return jresult;
92381 }
92382
92383
92384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
92385   unsigned int jresult ;
92386   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92387   std::string *arg2 = 0 ;
92388   uint32_t result;
92389
92390   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92391   if (!jarg2) {
92392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92393     return 0;
92394   }
92395   std::string arg2_str(jarg2);
92396   arg2 = &arg2_str;
92397   {
92398     try {
92399       result = (arg1)->Load((std::string const &)*arg2);
92400     } catch (std::out_of_range& e) {
92401       {
92402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92403       };
92404     } catch (std::exception& e) {
92405       {
92406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92407       };
92408     } catch (Dali::DaliException e) {
92409       {
92410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92411       };
92412     } catch (...) {
92413       {
92414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92415       };
92416     }
92417   }
92418
92419   jresult = result;
92420
92421   //argout typemap for const std::string&
92422
92423   return jresult;
92424 }
92425
92426
92427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
92428   unsigned int jresult ;
92429   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92430   std::string *arg2 = 0 ;
92431   Dali::ImageDimensions arg3 ;
92432   Dali::ImageDimensions *argp3 ;
92433   uint32_t result;
92434
92435   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92436   if (!jarg2) {
92437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92438     return 0;
92439   }
92440   std::string arg2_str(jarg2);
92441   arg2 = &arg2_str;
92442   argp3 = (Dali::ImageDimensions *)jarg3;
92443   if (!argp3) {
92444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92445     return 0;
92446   }
92447   arg3 = *argp3;
92448   {
92449     try {
92450       result = (arg1)->Load((std::string const &)*arg2,arg3);
92451     } catch (std::out_of_range& e) {
92452       {
92453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92454       };
92455     } catch (std::exception& e) {
92456       {
92457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92458       };
92459     } catch (Dali::DaliException e) {
92460       {
92461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92462       };
92463     } catch (...) {
92464       {
92465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92466       };
92467     }
92468   }
92469
92470   jresult = result;
92471
92472   //argout typemap for const std::string&
92473
92474   return jresult;
92475 }
92476
92477
92478 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
92479   unsigned int jresult ;
92480   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92481   std::string *arg2 = 0 ;
92482   Dali::ImageDimensions arg3 ;
92483   Dali::FittingMode::Type arg4 ;
92484   Dali::SamplingMode::Type arg5 ;
92485   bool arg6 ;
92486   Dali::ImageDimensions *argp3 ;
92487   uint32_t result;
92488
92489   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92490   if (!jarg2) {
92491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92492     return 0;
92493   }
92494   std::string arg2_str(jarg2);
92495   arg2 = &arg2_str;
92496   argp3 = (Dali::ImageDimensions *)jarg3;
92497   if (!argp3) {
92498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92499     return 0;
92500   }
92501   arg3 = *argp3;
92502   arg4 = (Dali::FittingMode::Type)jarg4;
92503   arg5 = (Dali::SamplingMode::Type)jarg5;
92504   arg6 = jarg6 ? true : false;
92505   {
92506     try {
92507       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
92508     } catch (std::out_of_range& e) {
92509       {
92510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92511       };
92512     } catch (std::exception& e) {
92513       {
92514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92515       };
92516     } catch (Dali::DaliException e) {
92517       {
92518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92519       };
92520     } catch (...) {
92521       {
92522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92523       };
92524     }
92525   }
92526
92527   jresult = result;
92528
92529   //argout typemap for const std::string&
92530
92531   return jresult;
92532 }
92533
92534
92535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
92536   unsigned int jresult ;
92537   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92538   uint32_t arg2 ;
92539   bool result;
92540
92541   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92542   arg2 = (uint32_t)jarg2;
92543   {
92544     try {
92545       result = (bool)(arg1)->Cancel(arg2);
92546     } catch (std::out_of_range& e) {
92547       {
92548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92549       };
92550     } catch (std::exception& e) {
92551       {
92552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92553       };
92554     } catch (Dali::DaliException e) {
92555       {
92556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92557       };
92558     } catch (...) {
92559       {
92560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92561       };
92562     }
92563   }
92564
92565   jresult = result;
92566   return jresult;
92567 }
92568
92569
92570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
92571   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92572
92573   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92574   {
92575     try {
92576       (arg1)->CancelAll();
92577     } catch (std::out_of_range& e) {
92578       {
92579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92580       };
92581     } catch (std::exception& e) {
92582       {
92583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92584       };
92585     } catch (Dali::DaliException e) {
92586       {
92587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92588       };
92589     } catch (...) {
92590       {
92591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92592       };
92593     }
92594   }
92595
92596 }
92597
92598
92599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92600   void * jresult ;
92601   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92602   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92603
92604   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92605   {
92606     try {
92607       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92608     } catch (std::out_of_range& e) {
92609       {
92610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92611       };
92612     } catch (std::exception& e) {
92613       {
92614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92615       };
92616     } catch (Dali::DaliException e) {
92617       {
92618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92619       };
92620     } catch (...) {
92621       {
92622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92623       };
92624     }
92625   }
92626
92627   jresult = (void *)result;
92628   return jresult;
92629 }
92630
92631
92632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
92633   void * jresult ;
92634   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
92635   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92636
92637   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
92638   {
92639     try {
92640       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
92641     } catch (std::out_of_range& e) {
92642       {
92643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92644       };
92645     } catch (std::exception& e) {
92646       {
92647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92648       };
92649     } catch (Dali::DaliException e) {
92650       {
92651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92652       };
92653     } catch (...) {
92654       {
92655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92656       };
92657     }
92658   }
92659
92660   jresult = (void *)result;
92661   return jresult;
92662 }
92663
92664
92665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92666   void * jresult ;
92667   std::string *arg1 = 0 ;
92668   Dali::PixelData result;
92669
92670   if (!jarg1) {
92671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92672     return 0;
92673   }
92674   std::string arg1_str(jarg1);
92675   arg1 = &arg1_str;
92676   {
92677     try {
92678       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92679     } catch (std::out_of_range& e) {
92680       {
92681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92682       };
92683     } catch (std::exception& e) {
92684       {
92685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92686       };
92687     } catch (Dali::DaliException e) {
92688       {
92689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92690       };
92691     } catch (...) {
92692       {
92693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92694       };
92695     }
92696   }
92697
92698   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92699
92700   //argout typemap for const std::string&
92701
92702   return jresult;
92703 }
92704
92705
92706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92707   void * jresult ;
92708   std::string *arg1 = 0 ;
92709   Dali::ImageDimensions arg2 ;
92710   Dali::ImageDimensions *argp2 ;
92711   Dali::PixelData result;
92712
92713   if (!jarg1) {
92714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92715     return 0;
92716   }
92717   std::string arg1_str(jarg1);
92718   arg1 = &arg1_str;
92719   argp2 = (Dali::ImageDimensions *)jarg2;
92720   if (!argp2) {
92721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92722     return 0;
92723   }
92724   arg2 = *argp2;
92725   {
92726     try {
92727       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92728     } catch (std::out_of_range& e) {
92729       {
92730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92731       };
92732     } catch (std::exception& e) {
92733       {
92734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92735       };
92736     } catch (Dali::DaliException e) {
92737       {
92738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92739       };
92740     } catch (...) {
92741       {
92742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92743       };
92744     }
92745   }
92746
92747   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92748
92749   //argout typemap for const std::string&
92750
92751   return jresult;
92752 }
92753
92754
92755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92756   void * jresult ;
92757   std::string *arg1 = 0 ;
92758   Dali::ImageDimensions arg2 ;
92759   Dali::FittingMode::Type arg3 ;
92760   Dali::SamplingMode::Type arg4 ;
92761   bool arg5 ;
92762   Dali::ImageDimensions *argp2 ;
92763   Dali::PixelData result;
92764
92765   if (!jarg1) {
92766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92767     return 0;
92768   }
92769   std::string arg1_str(jarg1);
92770   arg1 = &arg1_str;
92771   argp2 = (Dali::ImageDimensions *)jarg2;
92772   if (!argp2) {
92773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92774     return 0;
92775   }
92776   arg2 = *argp2;
92777   arg3 = (Dali::FittingMode::Type)jarg3;
92778   arg4 = (Dali::SamplingMode::Type)jarg4;
92779   arg5 = jarg5 ? true : false;
92780   {
92781     try {
92782       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92783     } catch (std::out_of_range& e) {
92784       {
92785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92786       };
92787     } catch (std::exception& e) {
92788       {
92789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92790       };
92791     } catch (Dali::DaliException e) {
92792       {
92793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92794       };
92795     } catch (...) {
92796       {
92797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92798       };
92799     }
92800   }
92801
92802   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92803
92804   //argout typemap for const std::string&
92805
92806   return jresult;
92807 }
92808
92809
92810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92811   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92812
92813   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92814   {
92815     try {
92816       delete arg1;
92817     } catch (std::out_of_range& e) {
92818       {
92819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92820       };
92821     } catch (std::exception& e) {
92822       {
92823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92824       };
92825     } catch (Dali::DaliException e) {
92826       {
92827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92828       };
92829     } catch (...) {
92830       {
92831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92832       };
92833     }
92834   }
92835
92836 }
92837
92838
92839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92840   void * jresult ;
92841   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92842   Dali::Actor arg2 ;
92843   Dali::Actor arg3 ;
92844   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92845   Dali::Actor *argp2 ;
92846   Dali::Actor *argp3 ;
92847   Dali::Actor result;
92848
92849   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92850   argp2 = (Dali::Actor *)jarg2;
92851   if (!argp2) {
92852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92853     return 0;
92854   }
92855   arg2 = *argp2;
92856   argp3 = (Dali::Actor *)jarg3;
92857   if (!argp3) {
92858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92859     return 0;
92860   }
92861   arg3 = *argp3;
92862   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92863   {
92864     try {
92865       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92866     } catch (std::out_of_range& e) {
92867       {
92868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92869       };
92870     } catch (std::exception& e) {
92871       {
92872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92873       };
92874     } catch (Dali::DaliException e) {
92875       {
92876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92877       };
92878     } catch (...) {
92879       {
92880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92881       };
92882     }
92883   }
92884
92885   jresult = new Dali::Actor((const Dali::Actor &)result);
92886   return jresult;
92887 }
92888
92889
92890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92891   void * jresult ;
92892   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92893
92894   {
92895     try {
92896       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92897     } catch (std::out_of_range& e) {
92898       {
92899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92900       };
92901     } catch (std::exception& e) {
92902       {
92903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92904       };
92905     } catch (Dali::DaliException e) {
92906       {
92907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92908       };
92909     } catch (...) {
92910       {
92911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92912       };
92913     }
92914   }
92915
92916   jresult = (void *)result;
92917   return jresult;
92918 }
92919
92920
92921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92922   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92923   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92924   if (director) {
92925     director->swig_connect_director(callback0);
92926   }
92927 }
92928
92929
92930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92931   KeyboardFocusManager arg1 ;
92932   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92933   KeyboardFocusManager *argp1 ;
92934
92935   argp1 = (KeyboardFocusManager *)jarg1;
92936   if (!argp1) {
92937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92938     return ;
92939   }
92940   arg1 = *argp1;
92941   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92942   if (!arg2) {
92943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92944     return ;
92945   }
92946   {
92947     try {
92948       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92949     } catch (std::out_of_range& e) {
92950       {
92951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92952       };
92953     } catch (std::exception& e) {
92954       {
92955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92956       };
92957     } catch (Dali::DaliException e) {
92958       {
92959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92960       };
92961     } catch (...) {
92962       {
92963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92964       };
92965     }
92966   }
92967
92968 }
92969
92970
92971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92972   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92973
92974   arg1 = (std::vector< unsigned int > *)jarg1;
92975   {
92976     try {
92977       (arg1)->clear();
92978     } catch (std::out_of_range& e) {
92979       {
92980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92981       };
92982     } catch (std::exception& e) {
92983       {
92984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92985       };
92986     } catch (Dali::DaliException e) {
92987       {
92988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92989       };
92990     } catch (...) {
92991       {
92992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92993       };
92994     }
92995   }
92996
92997 }
92998
92999
93000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
93001   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93002   unsigned int *arg2 = 0 ;
93003   unsigned int temp2 ;
93004
93005   arg1 = (std::vector< unsigned int > *)jarg1;
93006   temp2 = (unsigned int)jarg2;
93007   arg2 = &temp2;
93008   {
93009     try {
93010       (arg1)->push_back((unsigned int const &)*arg2);
93011     } catch (std::out_of_range& e) {
93012       {
93013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93014       };
93015     } catch (std::exception& e) {
93016       {
93017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93018       };
93019     } catch (Dali::DaliException e) {
93020       {
93021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93022       };
93023     } catch (...) {
93024       {
93025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93026       };
93027     }
93028   }
93029
93030 }
93031
93032
93033 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
93034   unsigned long jresult ;
93035   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93036   std::vector< unsigned int >::size_type result;
93037
93038   arg1 = (std::vector< unsigned int > *)jarg1;
93039   {
93040     try {
93041       result = ((std::vector< unsigned int > const *)arg1)->size();
93042     } catch (std::out_of_range& e) {
93043       {
93044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93045       };
93046     } catch (std::exception& e) {
93047       {
93048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93049       };
93050     } catch (Dali::DaliException e) {
93051       {
93052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93053       };
93054     } catch (...) {
93055       {
93056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93057       };
93058     }
93059   }
93060
93061   jresult = (unsigned long)result;
93062   return jresult;
93063 }
93064
93065
93066 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
93067   unsigned long jresult ;
93068   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93069   std::vector< unsigned int >::size_type result;
93070
93071   arg1 = (std::vector< unsigned int > *)jarg1;
93072   {
93073     try {
93074       result = ((std::vector< unsigned int > const *)arg1)->capacity();
93075     } catch (std::out_of_range& e) {
93076       {
93077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93078       };
93079     } catch (std::exception& e) {
93080       {
93081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93082       };
93083     } catch (Dali::DaliException e) {
93084       {
93085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93086       };
93087     } catch (...) {
93088       {
93089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93090       };
93091     }
93092   }
93093
93094   jresult = (unsigned long)result;
93095   return jresult;
93096 }
93097
93098
93099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
93100   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93101   std::vector< unsigned int >::size_type arg2 ;
93102
93103   arg1 = (std::vector< unsigned int > *)jarg1;
93104   arg2 = (std::vector< unsigned int >::size_type)jarg2;
93105   {
93106     try {
93107       (arg1)->reserve(arg2);
93108     } catch (std::out_of_range& e) {
93109       {
93110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93111       };
93112     } catch (std::exception& e) {
93113       {
93114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93115       };
93116     } catch (Dali::DaliException e) {
93117       {
93118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93119       };
93120     } catch (...) {
93121       {
93122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93123       };
93124     }
93125   }
93126
93127 }
93128
93129
93130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
93131   void * jresult ;
93132   std::vector< unsigned int > *result = 0 ;
93133
93134   {
93135     try {
93136       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
93137     } catch (std::out_of_range& e) {
93138       {
93139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93140       };
93141     } catch (std::exception& e) {
93142       {
93143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93144       };
93145     } catch (Dali::DaliException e) {
93146       {
93147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93148       };
93149     } catch (...) {
93150       {
93151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93152       };
93153     }
93154   }
93155
93156   jresult = (void *)result;
93157   return jresult;
93158 }
93159
93160
93161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
93162   void * jresult ;
93163   std::vector< unsigned int > *arg1 = 0 ;
93164   std::vector< unsigned int > *result = 0 ;
93165
93166   arg1 = (std::vector< unsigned int > *)jarg1;
93167   if (!arg1) {
93168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93169     return 0;
93170   }
93171   {
93172     try {
93173       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
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_2(int jarg1) {
93199   void * jresult ;
93200   int arg1 ;
93201   std::vector< unsigned int > *result = 0 ;
93202
93203   arg1 = (int)jarg1;
93204   {
93205     try {
93206       try {
93207         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
93208       }
93209       catch(std::out_of_range &_e) {
93210         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93211         return 0;
93212       }
93213
93214     } catch (std::out_of_range& e) {
93215       {
93216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93217       };
93218     } catch (std::exception& e) {
93219       {
93220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93221       };
93222     } catch (Dali::DaliException e) {
93223       {
93224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93225       };
93226     } catch (...) {
93227       {
93228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93229       };
93230     }
93231   }
93232
93233   jresult = (void *)result;
93234   return jresult;
93235 }
93236
93237
93238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
93239   unsigned int jresult ;
93240   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93241   int arg2 ;
93242   unsigned int result;
93243
93244   arg1 = (std::vector< unsigned int > *)jarg1;
93245   arg2 = (int)jarg2;
93246   {
93247     try {
93248       try {
93249         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
93250       }
93251       catch(std::out_of_range &_e) {
93252         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93253         return 0;
93254       }
93255
93256     } catch (std::out_of_range& e) {
93257       {
93258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93259       };
93260     } catch (std::exception& e) {
93261       {
93262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93263       };
93264     } catch (Dali::DaliException e) {
93265       {
93266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93267       };
93268     } catch (...) {
93269       {
93270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93271       };
93272     }
93273   }
93274
93275   jresult = result;
93276   return jresult;
93277 }
93278
93279
93280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
93281   unsigned int jresult ;
93282   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93283   int arg2 ;
93284   unsigned int *result = 0 ;
93285
93286   arg1 = (std::vector< unsigned int > *)jarg1;
93287   arg2 = (int)jarg2;
93288   {
93289     try {
93290       try {
93291         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
93292       }
93293       catch(std::out_of_range &_e) {
93294         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93295         return 0;
93296       }
93297
93298     } catch (std::out_of_range& e) {
93299       {
93300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93301       };
93302     } catch (std::exception& e) {
93303       {
93304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93305       };
93306     } catch (Dali::DaliException e) {
93307       {
93308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93309       };
93310     } catch (...) {
93311       {
93312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93313       };
93314     }
93315   }
93316
93317   jresult = *result;
93318   return jresult;
93319 }
93320
93321
93322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
93323   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93324   int arg2 ;
93325   unsigned int *arg3 = 0 ;
93326   unsigned int temp3 ;
93327
93328   arg1 = (std::vector< unsigned int > *)jarg1;
93329   arg2 = (int)jarg2;
93330   temp3 = (unsigned int)jarg3;
93331   arg3 = &temp3;
93332   {
93333     try {
93334       try {
93335         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
93336       }
93337       catch(std::out_of_range &_e) {
93338         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93339         return ;
93340       }
93341
93342     } catch (std::out_of_range& e) {
93343       {
93344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93345       };
93346     } catch (std::exception& e) {
93347       {
93348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93349       };
93350     } catch (Dali::DaliException e) {
93351       {
93352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93353       };
93354     } catch (...) {
93355       {
93356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93357       };
93358     }
93359   }
93360
93361 }
93362
93363
93364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
93365   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93366   std::vector< unsigned int > *arg2 = 0 ;
93367
93368   arg1 = (std::vector< unsigned int > *)jarg1;
93369   arg2 = (std::vector< unsigned int > *)jarg2;
93370   if (!arg2) {
93371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93372     return ;
93373   }
93374   {
93375     try {
93376       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
93377     } catch (std::out_of_range& e) {
93378       {
93379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93380       };
93381     } catch (std::exception& e) {
93382       {
93383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93384       };
93385     } catch (Dali::DaliException e) {
93386       {
93387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93388       };
93389     } catch (...) {
93390       {
93391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93392       };
93393     }
93394   }
93395
93396 }
93397
93398
93399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93400   void * jresult ;
93401   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93402   int arg2 ;
93403   int arg3 ;
93404   std::vector< unsigned int > *result = 0 ;
93405
93406   arg1 = (std::vector< unsigned int > *)jarg1;
93407   arg2 = (int)jarg2;
93408   arg3 = (int)jarg3;
93409   {
93410     try {
93411       try {
93412         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
93413       }
93414       catch(std::out_of_range &_e) {
93415         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93416         return 0;
93417       }
93418       catch(std::invalid_argument &_e) {
93419         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93420         return 0;
93421       }
93422
93423     } catch (std::out_of_range& e) {
93424       {
93425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93426       };
93427     } catch (std::exception& e) {
93428       {
93429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93430       };
93431     } catch (Dali::DaliException e) {
93432       {
93433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93434       };
93435     } catch (...) {
93436       {
93437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93438       };
93439     }
93440   }
93441
93442   jresult = (void *)result;
93443   return jresult;
93444 }
93445
93446
93447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
93448   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93449   int arg2 ;
93450   unsigned int *arg3 = 0 ;
93451   unsigned int temp3 ;
93452
93453   arg1 = (std::vector< unsigned int > *)jarg1;
93454   arg2 = (int)jarg2;
93455   temp3 = (unsigned int)jarg3;
93456   arg3 = &temp3;
93457   {
93458     try {
93459       try {
93460         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
93461       }
93462       catch(std::out_of_range &_e) {
93463         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93464         return ;
93465       }
93466
93467     } catch (std::out_of_range& e) {
93468       {
93469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93470       };
93471     } catch (std::exception& e) {
93472       {
93473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93474       };
93475     } catch (Dali::DaliException e) {
93476       {
93477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93478       };
93479     } catch (...) {
93480       {
93481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93482       };
93483     }
93484   }
93485
93486 }
93487
93488
93489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93490   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93491   int arg2 ;
93492   std::vector< unsigned int > *arg3 = 0 ;
93493
93494   arg1 = (std::vector< unsigned int > *)jarg1;
93495   arg2 = (int)jarg2;
93496   arg3 = (std::vector< unsigned int > *)jarg3;
93497   if (!arg3) {
93498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93499     return ;
93500   }
93501   {
93502     try {
93503       try {
93504         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93505       }
93506       catch(std::out_of_range &_e) {
93507         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93508         return ;
93509       }
93510
93511     } catch (std::out_of_range& e) {
93512       {
93513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93514       };
93515     } catch (std::exception& e) {
93516       {
93517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93518       };
93519     } catch (Dali::DaliException e) {
93520       {
93521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93522       };
93523     } catch (...) {
93524       {
93525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93526       };
93527     }
93528   }
93529
93530 }
93531
93532
93533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
93534   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93535   int arg2 ;
93536
93537   arg1 = (std::vector< unsigned int > *)jarg1;
93538   arg2 = (int)jarg2;
93539   {
93540     try {
93541       try {
93542         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
93543       }
93544       catch(std::out_of_range &_e) {
93545         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93546         return ;
93547       }
93548
93549     } catch (std::out_of_range& e) {
93550       {
93551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93552       };
93553     } catch (std::exception& e) {
93554       {
93555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93556       };
93557     } catch (Dali::DaliException e) {
93558       {
93559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93560       };
93561     } catch (...) {
93562       {
93563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93564       };
93565     }
93566   }
93567
93568 }
93569
93570
93571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93572   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93573   int arg2 ;
93574   int arg3 ;
93575
93576   arg1 = (std::vector< unsigned int > *)jarg1;
93577   arg2 = (int)jarg2;
93578   arg3 = (int)jarg3;
93579   {
93580     try {
93581       try {
93582         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
93583       }
93584       catch(std::out_of_range &_e) {
93585         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93586         return ;
93587       }
93588       catch(std::invalid_argument &_e) {
93589         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93590         return ;
93591       }
93592
93593     } catch (std::out_of_range& e) {
93594       {
93595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93596       };
93597     } catch (std::exception& e) {
93598       {
93599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93600       };
93601     } catch (Dali::DaliException e) {
93602       {
93603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93604       };
93605     } catch (...) {
93606       {
93607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93608       };
93609     }
93610   }
93611
93612 }
93613
93614
93615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93616   void * jresult ;
93617   unsigned int *arg1 = 0 ;
93618   int arg2 ;
93619   unsigned int temp1 ;
93620   std::vector< unsigned int > *result = 0 ;
93621
93622   temp1 = (unsigned int)jarg1;
93623   arg1 = &temp1;
93624   arg2 = (int)jarg2;
93625   {
93626     try {
93627       try {
93628         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93629       }
93630       catch(std::out_of_range &_e) {
93631         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93632         return 0;
93633       }
93634
93635     } catch (std::out_of_range& e) {
93636       {
93637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93638       };
93639     } catch (std::exception& e) {
93640       {
93641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93642       };
93643     } catch (Dali::DaliException e) {
93644       {
93645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93646       };
93647     } catch (...) {
93648       {
93649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93650       };
93651     }
93652   }
93653
93654   jresult = (void *)result;
93655   return jresult;
93656 }
93657
93658
93659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93660   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93661
93662   arg1 = (std::vector< unsigned int > *)jarg1;
93663   {
93664     try {
93665       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93666     } catch (std::out_of_range& e) {
93667       {
93668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93669       };
93670     } catch (std::exception& e) {
93671       {
93672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93673       };
93674     } catch (Dali::DaliException e) {
93675       {
93676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93677       };
93678     } catch (...) {
93679       {
93680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93681       };
93682     }
93683   }
93684
93685 }
93686
93687
93688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93689   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93690   int arg2 ;
93691   int arg3 ;
93692
93693   arg1 = (std::vector< unsigned int > *)jarg1;
93694   arg2 = (int)jarg2;
93695   arg3 = (int)jarg3;
93696   {
93697     try {
93698       try {
93699         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93700       }
93701       catch(std::out_of_range &_e) {
93702         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93703         return ;
93704       }
93705       catch(std::invalid_argument &_e) {
93706         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93707         return ;
93708       }
93709
93710     } catch (std::out_of_range& e) {
93711       {
93712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93713       };
93714     } catch (std::exception& e) {
93715       {
93716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93717       };
93718     } catch (Dali::DaliException e) {
93719       {
93720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93721       };
93722     } catch (...) {
93723       {
93724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93725       };
93726     }
93727   }
93728
93729 }
93730
93731
93732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93733   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93734   int arg2 ;
93735   std::vector< unsigned int > *arg3 = 0 ;
93736
93737   arg1 = (std::vector< unsigned int > *)jarg1;
93738   arg2 = (int)jarg2;
93739   arg3 = (std::vector< unsigned int > *)jarg3;
93740   if (!arg3) {
93741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93742     return ;
93743   }
93744   {
93745     try {
93746       try {
93747         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93748       }
93749       catch(std::out_of_range &_e) {
93750         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93751         return ;
93752       }
93753
93754     } catch (std::out_of_range& e) {
93755       {
93756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93757       };
93758     } catch (std::exception& e) {
93759       {
93760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93761       };
93762     } catch (Dali::DaliException e) {
93763       {
93764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93765       };
93766     } catch (...) {
93767       {
93768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93769       };
93770     }
93771   }
93772
93773 }
93774
93775
93776 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93777   unsigned int jresult ;
93778   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93779   unsigned int *arg2 = 0 ;
93780   unsigned int temp2 ;
93781   bool result;
93782
93783   arg1 = (std::vector< unsigned int > *)jarg1;
93784   temp2 = (unsigned int)jarg2;
93785   arg2 = &temp2;
93786   {
93787     try {
93788       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93789     } catch (std::out_of_range& e) {
93790       {
93791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93792       };
93793     } catch (std::exception& e) {
93794       {
93795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93796       };
93797     } catch (Dali::DaliException e) {
93798       {
93799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93800       };
93801     } catch (...) {
93802       {
93803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93804       };
93805     }
93806   }
93807
93808   jresult = result;
93809   return jresult;
93810 }
93811
93812
93813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93814   int jresult ;
93815   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93816   unsigned int *arg2 = 0 ;
93817   unsigned int temp2 ;
93818   int result;
93819
93820   arg1 = (std::vector< unsigned int > *)jarg1;
93821   temp2 = (unsigned int)jarg2;
93822   arg2 = &temp2;
93823   {
93824     try {
93825       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(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_LastIndexOf(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__LastIndexOf(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 unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93888   unsigned int jresult ;
93889   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93890   unsigned int *arg2 = 0 ;
93891   unsigned int temp2 ;
93892   bool result;
93893
93894   arg1 = (std::vector< unsigned int > *)jarg1;
93895   temp2 = (unsigned int)jarg2;
93896   arg2 = &temp2;
93897   {
93898     try {
93899       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(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 void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93925   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93926
93927   arg1 = (std::vector< unsigned int > *)jarg1;
93928   {
93929     try {
93930       delete arg1;
93931     } catch (std::out_of_range& e) {
93932       {
93933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93934       };
93935     } catch (std::exception& e) {
93936       {
93937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93938       };
93939     } catch (Dali::DaliException e) {
93940       {
93941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93942       };
93943     } catch (...) {
93944       {
93945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93946       };
93947     }
93948   }
93949
93950 }
93951
93952
93953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93954   void * jresult ;
93955   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93956
93957   {
93958     try {
93959       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93960     } catch (std::out_of_range& e) {
93961       {
93962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93963       };
93964     } catch (std::exception& e) {
93965       {
93966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93967       };
93968     } catch (Dali::DaliException e) {
93969       {
93970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93971       };
93972     } catch (...) {
93973       {
93974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93975       };
93976     }
93977   }
93978
93979   jresult = (void *)result;
93980   return jresult;
93981 }
93982
93983
93984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93985   void * jresult ;
93986   unsigned int arg1 ;
93987   Dali::Actor arg2 ;
93988   Dali::Actor *argp2 ;
93989   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93990
93991   arg1 = (unsigned int)jarg1;
93992   argp2 = (Dali::Actor *)jarg2;
93993   if (!argp2) {
93994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93995     return 0;
93996   }
93997   arg2 = *argp2;
93998   {
93999     try {
94000       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
94001     } catch (std::out_of_range& e) {
94002       {
94003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94004       };
94005     } catch (std::exception& e) {
94006       {
94007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94008       };
94009     } catch (Dali::DaliException e) {
94010       {
94011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94012       };
94013     } catch (...) {
94014       {
94015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94016       };
94017     }
94018   }
94019
94020   jresult = (void *)result;
94021   return jresult;
94022 }
94023
94024
94025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
94026   void * jresult ;
94027   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94028   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94029
94030   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94031   if (!arg1) {
94032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94033     return 0;
94034   }
94035   {
94036     try {
94037       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
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_Item_first_set(void * jarg1, unsigned int jarg2) {
94063   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94064   unsigned int arg2 ;
94065
94066   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94067   arg2 = (unsigned int)jarg2;
94068   if (arg1) (arg1)->first = arg2;
94069 }
94070
94071
94072 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
94073   unsigned int jresult ;
94074   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94075   unsigned int result;
94076
94077   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94078   result = (unsigned int) ((arg1)->first);
94079   jresult = result;
94080   return jresult;
94081 }
94082
94083
94084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
94085   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94086   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
94087
94088   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94089   arg2 = (Dali::Actor *)jarg2;
94090   if (arg1) (arg1)->second = *arg2;
94091 }
94092
94093
94094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
94095   void * jresult ;
94096   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94097   Dali::Actor *result = 0 ;
94098
94099   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94100   result = (Dali::Actor *)& ((arg1)->second);
94101   jresult = (void *)result;
94102   return jresult;
94103 }
94104
94105
94106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
94107   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94108
94109   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94110   {
94111     try {
94112       delete arg1;
94113     } catch (std::out_of_range& e) {
94114       {
94115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94116       };
94117     } catch (std::exception& e) {
94118       {
94119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94120       };
94121     } catch (Dali::DaliException e) {
94122       {
94123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94124       };
94125     } catch (...) {
94126       {
94127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94128       };
94129     }
94130   }
94131
94132 }
94133
94134
94135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
94136   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94137
94138   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94139   {
94140     try {
94141       (arg1)->clear();
94142     } catch (std::out_of_range& e) {
94143       {
94144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94145       };
94146     } catch (std::exception& e) {
94147       {
94148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94149       };
94150     } catch (Dali::DaliException e) {
94151       {
94152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94153       };
94154     } catch (...) {
94155       {
94156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94157       };
94158     }
94159   }
94160
94161 }
94162
94163
94164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
94165   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94166   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
94167
94168   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94169   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
94170   if (!arg2) {
94171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94172     return ;
94173   }
94174   {
94175     try {
94176       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
94177     } catch (std::out_of_range& e) {
94178       {
94179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94180       };
94181     } catch (std::exception& e) {
94182       {
94183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94184       };
94185     } catch (Dali::DaliException e) {
94186       {
94187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94188       };
94189     } catch (...) {
94190       {
94191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94192       };
94193     }
94194   }
94195
94196 }
94197
94198
94199 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
94200   unsigned long jresult ;
94201   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94202   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94203
94204   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94205   {
94206     try {
94207       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
94208     } catch (std::out_of_range& e) {
94209       {
94210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94211       };
94212     } catch (std::exception& e) {
94213       {
94214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94215       };
94216     } catch (Dali::DaliException e) {
94217       {
94218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94219       };
94220     } catch (...) {
94221       {
94222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94223       };
94224     }
94225   }
94226
94227   jresult = (unsigned long)result;
94228   return jresult;
94229 }
94230
94231
94232 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
94233   unsigned long jresult ;
94234   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94235   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94236
94237   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94238   {
94239     try {
94240       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
94241     } catch (std::out_of_range& e) {
94242       {
94243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94244       };
94245     } catch (std::exception& e) {
94246       {
94247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94248       };
94249     } catch (Dali::DaliException e) {
94250       {
94251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94252       };
94253     } catch (...) {
94254       {
94255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94256       };
94257     }
94258   }
94259
94260   jresult = (unsigned long)result;
94261   return jresult;
94262 }
94263
94264
94265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
94266   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94267   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
94268
94269   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94270   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
94271   {
94272     try {
94273       (arg1)->reserve(arg2);
94274     } catch (std::out_of_range& e) {
94275       {
94276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94277       };
94278     } catch (std::exception& e) {
94279       {
94280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94281       };
94282     } catch (Dali::DaliException e) {
94283       {
94284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94285       };
94286     } catch (...) {
94287       {
94288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94289       };
94290     }
94291   }
94292
94293 }
94294
94295
94296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
94297   void * jresult ;
94298   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94299
94300   {
94301     try {
94302       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
94303     } catch (std::out_of_range& e) {
94304       {
94305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94306       };
94307     } catch (std::exception& e) {
94308       {
94309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94310       };
94311     } catch (Dali::DaliException e) {
94312       {
94313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94314       };
94315     } catch (...) {
94316       {
94317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94318       };
94319     }
94320   }
94321
94322   jresult = (void *)result;
94323   return jresult;
94324 }
94325
94326
94327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
94328   void * jresult ;
94329   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
94330   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94331
94332   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94333   if (!arg1) {
94334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94335     return 0;
94336   }
94337   {
94338     try {
94339       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);
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_2(int jarg1) {
94365   void * jresult ;
94366   int arg1 ;
94367   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94368
94369   arg1 = (int)jarg1;
94370   {
94371     try {
94372       try {
94373         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);
94374       }
94375       catch(std::out_of_range &_e) {
94376         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94377         return 0;
94378       }
94379
94380     } catch (std::out_of_range& e) {
94381       {
94382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94383       };
94384     } catch (std::exception& e) {
94385       {
94386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94387       };
94388     } catch (Dali::DaliException e) {
94389       {
94390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94391       };
94392     } catch (...) {
94393       {
94394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94395       };
94396     }
94397   }
94398
94399   jresult = (void *)result;
94400   return jresult;
94401 }
94402
94403
94404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
94405   void * jresult ;
94406   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94407   int arg2 ;
94408   std::pair< unsigned int,Dali::Actor > result;
94409
94410   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94411   arg2 = (int)jarg2;
94412   {
94413     try {
94414       try {
94415         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
94416       }
94417       catch(std::out_of_range &_e) {
94418         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94419         return 0;
94420       }
94421
94422     } catch (std::out_of_range& e) {
94423       {
94424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94425       };
94426     } catch (std::exception& e) {
94427       {
94428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94429       };
94430     } catch (Dali::DaliException e) {
94431       {
94432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94433       };
94434     } catch (...) {
94435       {
94436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94437       };
94438     }
94439   }
94440
94441   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
94442   return jresult;
94443 }
94444
94445
94446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
94447   void * jresult ;
94448   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94449   int arg2 ;
94450   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94451
94452   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94453   arg2 = (int)jarg2;
94454   {
94455     try {
94456       try {
94457         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
94458       }
94459       catch(std::out_of_range &_e) {
94460         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94461         return 0;
94462       }
94463
94464     } catch (std::out_of_range& e) {
94465       {
94466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94467       };
94468     } catch (std::exception& e) {
94469       {
94470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94471       };
94472     } catch (Dali::DaliException e) {
94473       {
94474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94475       };
94476     } catch (...) {
94477       {
94478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94479       };
94480     }
94481   }
94482
94483   jresult = (void *)result;
94484   return jresult;
94485 }
94486
94487
94488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94489   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94490   int arg2 ;
94491   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94492
94493   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94494   arg2 = (int)jarg2;
94495   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94496   if (!arg3) {
94497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94498     return ;
94499   }
94500   {
94501     try {
94502       try {
94503         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);
94504       }
94505       catch(std::out_of_range &_e) {
94506         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94507         return ;
94508       }
94509
94510     } catch (std::out_of_range& e) {
94511       {
94512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94513       };
94514     } catch (std::exception& e) {
94515       {
94516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94517       };
94518     } catch (Dali::DaliException e) {
94519       {
94520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94521       };
94522     } catch (...) {
94523       {
94524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94525       };
94526     }
94527   }
94528
94529 }
94530
94531
94532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
94533   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94534   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
94535
94536   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94537   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
94538   if (!arg2) {
94539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94540     return ;
94541   }
94542   {
94543     try {
94544       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);
94545     } catch (std::out_of_range& e) {
94546       {
94547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94548       };
94549     } catch (std::exception& e) {
94550       {
94551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94552       };
94553     } catch (Dali::DaliException e) {
94554       {
94555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94556       };
94557     } catch (...) {
94558       {
94559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94560       };
94561     }
94562   }
94563
94564 }
94565
94566
94567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94568   void * jresult ;
94569   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94570   int arg2 ;
94571   int arg3 ;
94572   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94573
94574   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94575   arg2 = (int)jarg2;
94576   arg3 = (int)jarg3;
94577   {
94578     try {
94579       try {
94580         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);
94581       }
94582       catch(std::out_of_range &_e) {
94583         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94584         return 0;
94585       }
94586       catch(std::invalid_argument &_e) {
94587         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94588         return 0;
94589       }
94590
94591     } catch (std::out_of_range& e) {
94592       {
94593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94594       };
94595     } catch (std::exception& e) {
94596       {
94597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94598       };
94599     } catch (Dali::DaliException e) {
94600       {
94601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94602       };
94603     } catch (...) {
94604       {
94605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94606       };
94607     }
94608   }
94609
94610   jresult = (void *)result;
94611   return jresult;
94612 }
94613
94614
94615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94616   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94617   int arg2 ;
94618   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94619
94620   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94621   arg2 = (int)jarg2;
94622   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94623   if (!arg3) {
94624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94625     return ;
94626   }
94627   {
94628     try {
94629       try {
94630         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);
94631       }
94632       catch(std::out_of_range &_e) {
94633         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94634         return ;
94635       }
94636
94637     } catch (std::out_of_range& e) {
94638       {
94639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94640       };
94641     } catch (std::exception& e) {
94642       {
94643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94644       };
94645     } catch (Dali::DaliException e) {
94646       {
94647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94648       };
94649     } catch (...) {
94650       {
94651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94652       };
94653     }
94654   }
94655
94656 }
94657
94658
94659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94660   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94661   int arg2 ;
94662   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94663
94664   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94665   arg2 = (int)jarg2;
94666   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94667   if (!arg3) {
94668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94669     return ;
94670   }
94671   {
94672     try {
94673       try {
94674         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);
94675       }
94676       catch(std::out_of_range &_e) {
94677         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94678         return ;
94679       }
94680
94681     } catch (std::out_of_range& e) {
94682       {
94683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94684       };
94685     } catch (std::exception& e) {
94686       {
94687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94688       };
94689     } catch (Dali::DaliException e) {
94690       {
94691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94692       };
94693     } catch (...) {
94694       {
94695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94696       };
94697     }
94698   }
94699
94700 }
94701
94702
94703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94704   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94705   int arg2 ;
94706
94707   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94708   arg2 = (int)jarg2;
94709   {
94710     try {
94711       try {
94712         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94713       }
94714       catch(std::out_of_range &_e) {
94715         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94716         return ;
94717       }
94718
94719     } catch (std::out_of_range& e) {
94720       {
94721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94722       };
94723     } catch (std::exception& e) {
94724       {
94725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94726       };
94727     } catch (Dali::DaliException e) {
94728       {
94729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94730       };
94731     } catch (...) {
94732       {
94733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94734       };
94735     }
94736   }
94737
94738 }
94739
94740
94741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94742   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94743   int arg2 ;
94744   int arg3 ;
94745
94746   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94747   arg2 = (int)jarg2;
94748   arg3 = (int)jarg3;
94749   {
94750     try {
94751       try {
94752         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94753       }
94754       catch(std::out_of_range &_e) {
94755         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94756         return ;
94757       }
94758       catch(std::invalid_argument &_e) {
94759         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94760         return ;
94761       }
94762
94763     } catch (std::out_of_range& e) {
94764       {
94765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94766       };
94767     } catch (std::exception& e) {
94768       {
94769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94770       };
94771     } catch (Dali::DaliException e) {
94772       {
94773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94774       };
94775     } catch (...) {
94776       {
94777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94778       };
94779     }
94780   }
94781
94782 }
94783
94784
94785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94786   void * jresult ;
94787   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94788   int arg2 ;
94789   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94790
94791   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94792   if (!arg1) {
94793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94794     return 0;
94795   }
94796   arg2 = (int)jarg2;
94797   {
94798     try {
94799       try {
94800         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);
94801       }
94802       catch(std::out_of_range &_e) {
94803         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94804         return 0;
94805       }
94806
94807     } catch (std::out_of_range& e) {
94808       {
94809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94810       };
94811     } catch (std::exception& e) {
94812       {
94813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94814       };
94815     } catch (Dali::DaliException e) {
94816       {
94817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94818       };
94819     } catch (...) {
94820       {
94821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94822       };
94823     }
94824   }
94825
94826   jresult = (void *)result;
94827   return jresult;
94828 }
94829
94830
94831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94832   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94833
94834   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94835   {
94836     try {
94837       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94838     } catch (std::out_of_range& e) {
94839       {
94840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94841       };
94842     } catch (std::exception& e) {
94843       {
94844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94845       };
94846     } catch (Dali::DaliException e) {
94847       {
94848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94849       };
94850     } catch (...) {
94851       {
94852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94853       };
94854     }
94855   }
94856
94857 }
94858
94859
94860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94861   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94862   int arg2 ;
94863   int arg3 ;
94864
94865   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94866   arg2 = (int)jarg2;
94867   arg3 = (int)jarg3;
94868   {
94869     try {
94870       try {
94871         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94872       }
94873       catch(std::out_of_range &_e) {
94874         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94875         return ;
94876       }
94877       catch(std::invalid_argument &_e) {
94878         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94879         return ;
94880       }
94881
94882     } catch (std::out_of_range& e) {
94883       {
94884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94885       };
94886     } catch (std::exception& e) {
94887       {
94888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94889       };
94890     } catch (Dali::DaliException e) {
94891       {
94892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94893       };
94894     } catch (...) {
94895       {
94896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94897       };
94898     }
94899   }
94900
94901 }
94902
94903
94904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94905   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94906   int arg2 ;
94907   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94908
94909   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94910   arg2 = (int)jarg2;
94911   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94912   if (!arg3) {
94913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94914     return ;
94915   }
94916   {
94917     try {
94918       try {
94919         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);
94920       }
94921       catch(std::out_of_range &_e) {
94922         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94923         return ;
94924       }
94925
94926     } catch (std::out_of_range& e) {
94927       {
94928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94929       };
94930     } catch (std::exception& e) {
94931       {
94932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94933       };
94934     } catch (Dali::DaliException e) {
94935       {
94936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94937       };
94938     } catch (...) {
94939       {
94940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94941       };
94942     }
94943   }
94944
94945 }
94946
94947
94948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94949   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94950
94951   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94952   {
94953     try {
94954       delete arg1;
94955     } catch (std::out_of_range& e) {
94956       {
94957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94958       };
94959     } catch (std::exception& e) {
94960       {
94961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94962       };
94963     } catch (Dali::DaliException e) {
94964       {
94965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94966       };
94967     } catch (...) {
94968       {
94969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94970       };
94971     }
94972   }
94973
94974 }
94975
94976
94977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94978   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94979
94980   arg1 = (std::vector< Dali::Actor > *)jarg1;
94981   {
94982     try {
94983       (arg1)->clear();
94984     } catch (std::out_of_range& e) {
94985       {
94986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94987       };
94988     } catch (std::exception& e) {
94989       {
94990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94991       };
94992     } catch (Dali::DaliException e) {
94993       {
94994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94995       };
94996     } catch (...) {
94997       {
94998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94999       };
95000     }
95001   }
95002
95003 }
95004
95005
95006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
95007   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95008   Dali::Actor *arg2 = 0 ;
95009
95010   arg1 = (std::vector< Dali::Actor > *)jarg1;
95011   arg2 = (Dali::Actor *)jarg2;
95012   if (!arg2) {
95013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95014     return ;
95015   }
95016   {
95017     try {
95018       (arg1)->push_back((Dali::Actor const &)*arg2);
95019     } catch (std::out_of_range& e) {
95020       {
95021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95022       };
95023     } catch (std::exception& e) {
95024       {
95025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95026       };
95027     } catch (Dali::DaliException e) {
95028       {
95029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95030       };
95031     } catch (...) {
95032       {
95033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95034       };
95035     }
95036   }
95037
95038 }
95039
95040
95041 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
95042   unsigned long jresult ;
95043   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95044   std::vector< Dali::Actor >::size_type result;
95045
95046   arg1 = (std::vector< Dali::Actor > *)jarg1;
95047   {
95048     try {
95049       result = ((std::vector< Dali::Actor > const *)arg1)->size();
95050     } catch (std::out_of_range& e) {
95051       {
95052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95053       };
95054     } catch (std::exception& e) {
95055       {
95056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95057       };
95058     } catch (Dali::DaliException e) {
95059       {
95060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95061       };
95062     } catch (...) {
95063       {
95064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95065       };
95066     }
95067   }
95068
95069   jresult = (unsigned long)result;
95070   return jresult;
95071 }
95072
95073
95074 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
95075   unsigned long jresult ;
95076   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95077   std::vector< Dali::Actor >::size_type result;
95078
95079   arg1 = (std::vector< Dali::Actor > *)jarg1;
95080   {
95081     try {
95082       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
95083     } catch (std::out_of_range& e) {
95084       {
95085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95086       };
95087     } catch (std::exception& e) {
95088       {
95089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95090       };
95091     } catch (Dali::DaliException e) {
95092       {
95093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95094       };
95095     } catch (...) {
95096       {
95097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95098       };
95099     }
95100   }
95101
95102   jresult = (unsigned long)result;
95103   return jresult;
95104 }
95105
95106
95107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
95108   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95109   std::vector< Dali::Actor >::size_type arg2 ;
95110
95111   arg1 = (std::vector< Dali::Actor > *)jarg1;
95112   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
95113   {
95114     try {
95115       (arg1)->reserve(arg2);
95116     } catch (std::out_of_range& e) {
95117       {
95118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95119       };
95120     } catch (std::exception& e) {
95121       {
95122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95123       };
95124     } catch (Dali::DaliException e) {
95125       {
95126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95127       };
95128     } catch (...) {
95129       {
95130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95131       };
95132     }
95133   }
95134
95135 }
95136
95137
95138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
95139   void * jresult ;
95140   std::vector< Dali::Actor > *result = 0 ;
95141
95142   {
95143     try {
95144       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
95145     } catch (std::out_of_range& e) {
95146       {
95147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95148       };
95149     } catch (std::exception& e) {
95150       {
95151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95152       };
95153     } catch (Dali::DaliException e) {
95154       {
95155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95156       };
95157     } catch (...) {
95158       {
95159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95160       };
95161     }
95162   }
95163
95164   jresult = (void *)result;
95165   return jresult;
95166 }
95167
95168
95169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
95170   void * jresult ;
95171   std::vector< Dali::Actor > *arg1 = 0 ;
95172   std::vector< Dali::Actor > *result = 0 ;
95173
95174   arg1 = (std::vector< Dali::Actor > *)jarg1;
95175   if (!arg1) {
95176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95177     return 0;
95178   }
95179   {
95180     try {
95181       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
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_2(int jarg1) {
95207   void * jresult ;
95208   int arg1 ;
95209   std::vector< Dali::Actor > *result = 0 ;
95210
95211   arg1 = (int)jarg1;
95212   {
95213     try {
95214       try {
95215         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
95216       }
95217       catch(std::out_of_range &_e) {
95218         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95219         return 0;
95220       }
95221
95222     } catch (std::out_of_range& e) {
95223       {
95224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95225       };
95226     } catch (std::exception& e) {
95227       {
95228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95229       };
95230     } catch (Dali::DaliException e) {
95231       {
95232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95233       };
95234     } catch (...) {
95235       {
95236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95237       };
95238     }
95239   }
95240
95241   jresult = (void *)result;
95242   return jresult;
95243 }
95244
95245
95246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
95247   void * jresult ;
95248   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95249   int arg2 ;
95250   Dali::Actor result;
95251
95252   arg1 = (std::vector< Dali::Actor > *)jarg1;
95253   arg2 = (int)jarg2;
95254   {
95255     try {
95256       try {
95257         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
95258       }
95259       catch(std::out_of_range &_e) {
95260         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95261         return 0;
95262       }
95263
95264     } catch (std::out_of_range& e) {
95265       {
95266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95267       };
95268     } catch (std::exception& e) {
95269       {
95270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95271       };
95272     } catch (Dali::DaliException e) {
95273       {
95274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95275       };
95276     } catch (...) {
95277       {
95278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95279       };
95280     }
95281   }
95282
95283   jresult = new Dali::Actor((const Dali::Actor &)result);
95284   return jresult;
95285 }
95286
95287
95288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
95289   void * jresult ;
95290   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95291   int arg2 ;
95292   Dali::Actor *result = 0 ;
95293
95294   arg1 = (std::vector< Dali::Actor > *)jarg1;
95295   arg2 = (int)jarg2;
95296   {
95297     try {
95298       try {
95299         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
95300       }
95301       catch(std::out_of_range &_e) {
95302         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95303         return 0;
95304       }
95305
95306     } catch (std::out_of_range& e) {
95307       {
95308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95309       };
95310     } catch (std::exception& e) {
95311       {
95312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95313       };
95314     } catch (Dali::DaliException e) {
95315       {
95316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95317       };
95318     } catch (...) {
95319       {
95320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95321       };
95322     }
95323   }
95324
95325   jresult = (void *)result;
95326   return jresult;
95327 }
95328
95329
95330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
95331   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95332   int arg2 ;
95333   Dali::Actor *arg3 = 0 ;
95334
95335   arg1 = (std::vector< Dali::Actor > *)jarg1;
95336   arg2 = (int)jarg2;
95337   arg3 = (Dali::Actor *)jarg3;
95338   if (!arg3) {
95339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95340     return ;
95341   }
95342   {
95343     try {
95344       try {
95345         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
95346       }
95347       catch(std::out_of_range &_e) {
95348         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95349         return ;
95350       }
95351
95352     } catch (std::out_of_range& e) {
95353       {
95354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95355       };
95356     } catch (std::exception& e) {
95357       {
95358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95359       };
95360     } catch (Dali::DaliException e) {
95361       {
95362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95363       };
95364     } catch (...) {
95365       {
95366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95367       };
95368     }
95369   }
95370
95371 }
95372
95373
95374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
95375   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95376   std::vector< Dali::Actor > *arg2 = 0 ;
95377
95378   arg1 = (std::vector< Dali::Actor > *)jarg1;
95379   arg2 = (std::vector< Dali::Actor > *)jarg2;
95380   if (!arg2) {
95381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95382     return ;
95383   }
95384   {
95385     try {
95386       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
95387     } catch (std::out_of_range& e) {
95388       {
95389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95390       };
95391     } catch (std::exception& e) {
95392       {
95393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95394       };
95395     } catch (Dali::DaliException e) {
95396       {
95397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95398       };
95399     } catch (...) {
95400       {
95401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95402       };
95403     }
95404   }
95405
95406 }
95407
95408
95409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
95410   void * jresult ;
95411   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95412   int arg2 ;
95413   int arg3 ;
95414   std::vector< Dali::Actor > *result = 0 ;
95415
95416   arg1 = (std::vector< Dali::Actor > *)jarg1;
95417   arg2 = (int)jarg2;
95418   arg3 = (int)jarg3;
95419   {
95420     try {
95421       try {
95422         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
95423       }
95424       catch(std::out_of_range &_e) {
95425         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95426         return 0;
95427       }
95428       catch(std::invalid_argument &_e) {
95429         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95430         return 0;
95431       }
95432
95433     } catch (std::out_of_range& e) {
95434       {
95435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95436       };
95437     } catch (std::exception& e) {
95438       {
95439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95440       };
95441     } catch (Dali::DaliException e) {
95442       {
95443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95444       };
95445     } catch (...) {
95446       {
95447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95448       };
95449     }
95450   }
95451
95452   jresult = (void *)result;
95453   return jresult;
95454 }
95455
95456
95457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
95458   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95459   int arg2 ;
95460   Dali::Actor *arg3 = 0 ;
95461
95462   arg1 = (std::vector< Dali::Actor > *)jarg1;
95463   arg2 = (int)jarg2;
95464   arg3 = (Dali::Actor *)jarg3;
95465   if (!arg3) {
95466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95467     return ;
95468   }
95469   {
95470     try {
95471       try {
95472         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
95473       }
95474       catch(std::out_of_range &_e) {
95475         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95476         return ;
95477       }
95478
95479     } catch (std::out_of_range& e) {
95480       {
95481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95482       };
95483     } catch (std::exception& e) {
95484       {
95485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95486       };
95487     } catch (Dali::DaliException e) {
95488       {
95489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95490       };
95491     } catch (...) {
95492       {
95493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95494       };
95495     }
95496   }
95497
95498 }
95499
95500
95501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
95502   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95503   int arg2 ;
95504   std::vector< Dali::Actor > *arg3 = 0 ;
95505
95506   arg1 = (std::vector< Dali::Actor > *)jarg1;
95507   arg2 = (int)jarg2;
95508   arg3 = (std::vector< Dali::Actor > *)jarg3;
95509   if (!arg3) {
95510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95511     return ;
95512   }
95513   {
95514     try {
95515       try {
95516         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95517       }
95518       catch(std::out_of_range &_e) {
95519         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95520         return ;
95521       }
95522
95523     } catch (std::out_of_range& e) {
95524       {
95525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95526       };
95527     } catch (std::exception& e) {
95528       {
95529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95530       };
95531     } catch (Dali::DaliException e) {
95532       {
95533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95534       };
95535     } catch (...) {
95536       {
95537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95538       };
95539     }
95540   }
95541
95542 }
95543
95544
95545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
95546   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95547   int arg2 ;
95548
95549   arg1 = (std::vector< Dali::Actor > *)jarg1;
95550   arg2 = (int)jarg2;
95551   {
95552     try {
95553       try {
95554         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
95555       }
95556       catch(std::out_of_range &_e) {
95557         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95558         return ;
95559       }
95560
95561     } catch (std::out_of_range& e) {
95562       {
95563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95564       };
95565     } catch (std::exception& e) {
95566       {
95567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95568       };
95569     } catch (Dali::DaliException e) {
95570       {
95571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95572       };
95573     } catch (...) {
95574       {
95575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95576       };
95577     }
95578   }
95579
95580 }
95581
95582
95583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
95584   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95585   int arg2 ;
95586   int arg3 ;
95587
95588   arg1 = (std::vector< Dali::Actor > *)jarg1;
95589   arg2 = (int)jarg2;
95590   arg3 = (int)jarg3;
95591   {
95592     try {
95593       try {
95594         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
95595       }
95596       catch(std::out_of_range &_e) {
95597         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95598         return ;
95599       }
95600       catch(std::invalid_argument &_e) {
95601         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95602         return ;
95603       }
95604
95605     } catch (std::out_of_range& e) {
95606       {
95607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95608       };
95609     } catch (std::exception& e) {
95610       {
95611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95612       };
95613     } catch (Dali::DaliException e) {
95614       {
95615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95616       };
95617     } catch (...) {
95618       {
95619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95620       };
95621     }
95622   }
95623
95624 }
95625
95626
95627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95628   void * jresult ;
95629   Dali::Actor *arg1 = 0 ;
95630   int arg2 ;
95631   std::vector< Dali::Actor > *result = 0 ;
95632
95633   arg1 = (Dali::Actor *)jarg1;
95634   if (!arg1) {
95635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95636     return 0;
95637   }
95638   arg2 = (int)jarg2;
95639   {
95640     try {
95641       try {
95642         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95643       }
95644       catch(std::out_of_range &_e) {
95645         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95646         return 0;
95647       }
95648
95649     } catch (std::out_of_range& e) {
95650       {
95651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95652       };
95653     } catch (std::exception& e) {
95654       {
95655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95656       };
95657     } catch (Dali::DaliException e) {
95658       {
95659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95660       };
95661     } catch (...) {
95662       {
95663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95664       };
95665     }
95666   }
95667
95668   jresult = (void *)result;
95669   return jresult;
95670 }
95671
95672
95673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95674   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95675
95676   arg1 = (std::vector< Dali::Actor > *)jarg1;
95677   {
95678     try {
95679       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95680     } catch (std::out_of_range& e) {
95681       {
95682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95683       };
95684     } catch (std::exception& e) {
95685       {
95686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95687       };
95688     } catch (Dali::DaliException e) {
95689       {
95690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95691       };
95692     } catch (...) {
95693       {
95694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95695       };
95696     }
95697   }
95698
95699 }
95700
95701
95702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95703   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95704   int arg2 ;
95705   int arg3 ;
95706
95707   arg1 = (std::vector< Dali::Actor > *)jarg1;
95708   arg2 = (int)jarg2;
95709   arg3 = (int)jarg3;
95710   {
95711     try {
95712       try {
95713         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95714       }
95715       catch(std::out_of_range &_e) {
95716         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95717         return ;
95718       }
95719       catch(std::invalid_argument &_e) {
95720         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95721         return ;
95722       }
95723
95724     } catch (std::out_of_range& e) {
95725       {
95726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95727       };
95728     } catch (std::exception& e) {
95729       {
95730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95731       };
95732     } catch (Dali::DaliException e) {
95733       {
95734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95735       };
95736     } catch (...) {
95737       {
95738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95739       };
95740     }
95741   }
95742
95743 }
95744
95745
95746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95747   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95748   int arg2 ;
95749   std::vector< Dali::Actor > *arg3 = 0 ;
95750
95751   arg1 = (std::vector< Dali::Actor > *)jarg1;
95752   arg2 = (int)jarg2;
95753   arg3 = (std::vector< Dali::Actor > *)jarg3;
95754   if (!arg3) {
95755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95756     return ;
95757   }
95758   {
95759     try {
95760       try {
95761         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95762       }
95763       catch(std::out_of_range &_e) {
95764         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95765         return ;
95766       }
95767
95768     } catch (std::out_of_range& e) {
95769       {
95770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95771       };
95772     } catch (std::exception& e) {
95773       {
95774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95775       };
95776     } catch (Dali::DaliException e) {
95777       {
95778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95779       };
95780     } catch (...) {
95781       {
95782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95783       };
95784     }
95785   }
95786
95787 }
95788
95789
95790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95791   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95792
95793   arg1 = (std::vector< Dali::Actor > *)jarg1;
95794   {
95795     try {
95796       delete arg1;
95797     } catch (std::out_of_range& e) {
95798       {
95799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95800       };
95801     } catch (std::exception& e) {
95802       {
95803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95804       };
95805     } catch (Dali::DaliException e) {
95806       {
95807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95808       };
95809     } catch (...) {
95810       {
95811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95812       };
95813     }
95814   }
95815
95816 }
95817
95818
95819 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95820   unsigned int jresult ;
95821   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95822   bool result;
95823
95824   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95825   {
95826     try {
95827       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95828     } catch (std::out_of_range& e) {
95829       {
95830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95831       };
95832     } catch (std::exception& e) {
95833       {
95834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95835       };
95836     } catch (Dali::DaliException e) {
95837       {
95838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95839       };
95840     } catch (...) {
95841       {
95842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95843       };
95844     }
95845   }
95846
95847   jresult = result;
95848   return jresult;
95849 }
95850
95851
95852 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95853   unsigned long jresult ;
95854   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95855   std::size_t result;
95856
95857   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95858   {
95859     try {
95860       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95861     } catch (std::out_of_range& e) {
95862       {
95863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95864       };
95865     } catch (std::exception& e) {
95866       {
95867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95868       };
95869     } catch (Dali::DaliException e) {
95870       {
95871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95872       };
95873     } catch (...) {
95874       {
95875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95876       };
95877     }
95878   }
95879
95880   jresult = (unsigned long)result;
95881   return jresult;
95882 }
95883
95884
95885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95886   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95887   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95888
95889   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95890   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95891   {
95892     try {
95893       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95894     } catch (std::out_of_range& e) {
95895       {
95896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95897       };
95898     } catch (std::exception& e) {
95899       {
95900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95901       };
95902     } catch (Dali::DaliException e) {
95903       {
95904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95905       };
95906     } catch (...) {
95907       {
95908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95909       };
95910     }
95911   }
95912
95913 }
95914
95915
95916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95917   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95918   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95919
95920   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95921   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95922   {
95923     try {
95924       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95925     } catch (std::out_of_range& e) {
95926       {
95927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95928       };
95929     } catch (std::exception& e) {
95930       {
95931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95932       };
95933     } catch (Dali::DaliException e) {
95934       {
95935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95936       };
95937     } catch (...) {
95938       {
95939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95940       };
95941     }
95942   }
95943
95944 }
95945
95946
95947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95948   unsigned int jresult ;
95949   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95950   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95951   bool result;
95952
95953   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95954   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95955   if (!arg2) {
95956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95957     return 0;
95958   }
95959   {
95960     try {
95961       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95962     } catch (std::out_of_range& e) {
95963       {
95964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95965       };
95966     } catch (std::exception& e) {
95967       {
95968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95969       };
95970     } catch (Dali::DaliException e) {
95971       {
95972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95973       };
95974     } catch (...) {
95975       {
95976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95977       };
95978     }
95979   }
95980
95981   jresult = result;
95982   return jresult;
95983 }
95984
95985
95986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95987   void * jresult ;
95988   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95989
95990   {
95991     try {
95992       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95993     } catch (std::out_of_range& e) {
95994       {
95995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95996       };
95997     } catch (std::exception& e) {
95998       {
95999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96000       };
96001     } catch (Dali::DaliException e) {
96002       {
96003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96004       };
96005     } catch (...) {
96006       {
96007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96008       };
96009     }
96010   }
96011
96012   jresult = (void *)result;
96013   return jresult;
96014 }
96015
96016
96017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
96018   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
96019
96020   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
96021   {
96022     try {
96023       delete arg1;
96024     } catch (std::out_of_range& e) {
96025       {
96026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96027       };
96028     } catch (std::exception& e) {
96029       {
96030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96031       };
96032     } catch (Dali::DaliException e) {
96033       {
96034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96035       };
96036     } catch (...) {
96037       {
96038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96039       };
96040     }
96041   }
96042
96043 }
96044
96045
96046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
96047   unsigned int jresult ;
96048   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96049   bool result;
96050
96051   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96052   {
96053     try {
96054       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);
96055     } catch (std::out_of_range& e) {
96056       {
96057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96058       };
96059     } catch (std::exception& e) {
96060       {
96061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96062       };
96063     } catch (Dali::DaliException e) {
96064       {
96065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96066       };
96067     } catch (...) {
96068       {
96069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96070       };
96071     }
96072   }
96073
96074   jresult = result;
96075   return jresult;
96076 }
96077
96078
96079 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
96080   unsigned long jresult ;
96081   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96082   std::size_t result;
96083
96084   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96085   {
96086     try {
96087       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);
96088     } catch (std::out_of_range& e) {
96089       {
96090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96091       };
96092     } catch (std::exception& e) {
96093       {
96094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96095       };
96096     } catch (Dali::DaliException e) {
96097       {
96098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96099       };
96100     } catch (...) {
96101       {
96102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96103       };
96104     }
96105   }
96106
96107   jresult = (unsigned long)result;
96108   return jresult;
96109 }
96110
96111
96112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
96113   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96114   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
96115
96116   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96117   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
96118   {
96119     try {
96120       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
96121     } catch (std::out_of_range& e) {
96122       {
96123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96124       };
96125     } catch (std::exception& e) {
96126       {
96127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96128       };
96129     } catch (Dali::DaliException e) {
96130       {
96131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96132       };
96133     } catch (...) {
96134       {
96135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96136       };
96137     }
96138   }
96139
96140 }
96141
96142
96143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
96144   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96145   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
96146
96147   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96148   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
96149   {
96150     try {
96151       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
96152     } catch (std::out_of_range& e) {
96153       {
96154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96155       };
96156     } catch (std::exception& e) {
96157       {
96158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96159       };
96160     } catch (Dali::DaliException e) {
96161       {
96162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96163       };
96164     } catch (...) {
96165       {
96166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96167       };
96168     }
96169   }
96170
96171 }
96172
96173
96174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96175   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96176   Dali::Actor arg2 ;
96177   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
96178   Dali::Actor *argp2 ;
96179
96180   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96181   argp2 = (Dali::Actor *)jarg2;
96182   if (!argp2) {
96183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96184     return ;
96185   }
96186   arg2 = *argp2;
96187   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
96188   {
96189     try {
96190       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
96191     } catch (std::out_of_range& e) {
96192       {
96193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96194       };
96195     } catch (std::exception& e) {
96196       {
96197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96198       };
96199     } catch (Dali::DaliException e) {
96200       {
96201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96202       };
96203     } catch (...) {
96204       {
96205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96206       };
96207     }
96208   }
96209
96210 }
96211
96212
96213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
96214   void * jresult ;
96215   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
96216
96217   {
96218     try {
96219       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
96220     } catch (std::out_of_range& e) {
96221       {
96222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96223       };
96224     } catch (std::exception& e) {
96225       {
96226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96227       };
96228     } catch (Dali::DaliException e) {
96229       {
96230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96231       };
96232     } catch (...) {
96233       {
96234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96235       };
96236     }
96237   }
96238
96239   jresult = (void *)result;
96240   return jresult;
96241 }
96242
96243
96244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
96245   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96246
96247   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96248   {
96249     try {
96250       delete arg1;
96251     } catch (std::out_of_range& e) {
96252       {
96253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96254       };
96255     } catch (std::exception& e) {
96256       {
96257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96258       };
96259     } catch (Dali::DaliException e) {
96260       {
96261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96262       };
96263     } catch (...) {
96264       {
96265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96266       };
96267     }
96268   }
96269
96270 }
96271
96272
96273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
96274   unsigned int jresult ;
96275   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96276   bool result;
96277
96278   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96279   {
96280     try {
96281       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96282     } catch (std::out_of_range& e) {
96283       {
96284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96285       };
96286     } catch (std::exception& e) {
96287       {
96288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96289       };
96290     } catch (Dali::DaliException e) {
96291       {
96292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96293       };
96294     } catch (...) {
96295       {
96296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96297       };
96298     }
96299   }
96300
96301   jresult = result;
96302   return jresult;
96303 }
96304
96305
96306 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
96307   unsigned long jresult ;
96308   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96309   std::size_t result;
96310
96311   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96312   {
96313     try {
96314       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96315     } catch (std::out_of_range& e) {
96316       {
96317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96318       };
96319     } catch (std::exception& e) {
96320       {
96321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96322       };
96323     } catch (Dali::DaliException e) {
96324       {
96325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96326       };
96327     } catch (...) {
96328       {
96329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96330       };
96331     }
96332   }
96333
96334   jresult = (unsigned long)result;
96335   return jresult;
96336 }
96337
96338
96339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
96340   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96341   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96342
96343   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96344   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96345   {
96346     try {
96347       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
96348     } catch (std::out_of_range& e) {
96349       {
96350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96351       };
96352     } catch (std::exception& e) {
96353       {
96354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96355       };
96356     } catch (Dali::DaliException e) {
96357       {
96358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96359       };
96360     } catch (...) {
96361       {
96362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96363       };
96364     }
96365   }
96366
96367 }
96368
96369
96370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96371   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96372   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96373
96374   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96375   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96376   {
96377     try {
96378       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
96379     } catch (std::out_of_range& e) {
96380       {
96381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96382       };
96383     } catch (std::exception& e) {
96384       {
96385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96386       };
96387     } catch (Dali::DaliException e) {
96388       {
96389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96390       };
96391     } catch (...) {
96392       {
96393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96394       };
96395     }
96396   }
96397
96398 }
96399
96400
96401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
96402   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96403   Dali::Actor arg2 ;
96404   Dali::Actor arg3 ;
96405   Dali::Actor *argp2 ;
96406   Dali::Actor *argp3 ;
96407
96408   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96409   argp2 = (Dali::Actor *)jarg2;
96410   if (!argp2) {
96411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96412     return ;
96413   }
96414   arg2 = *argp2;
96415   argp3 = (Dali::Actor *)jarg3;
96416   if (!argp3) {
96417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96418     return ;
96419   }
96420   arg3 = *argp3;
96421   {
96422     try {
96423       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
96424     } catch (std::out_of_range& e) {
96425       {
96426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96427       };
96428     } catch (std::exception& e) {
96429       {
96430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96431       };
96432     } catch (Dali::DaliException e) {
96433       {
96434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96435       };
96436     } catch (...) {
96437       {
96438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96439       };
96440     }
96441   }
96442
96443 }
96444
96445
96446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
96447   void * jresult ;
96448   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
96449
96450   {
96451     try {
96452       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
96453     } catch (std::out_of_range& e) {
96454       {
96455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96456       };
96457     } catch (std::exception& e) {
96458       {
96459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96460       };
96461     } catch (Dali::DaliException e) {
96462       {
96463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96464       };
96465     } catch (...) {
96466       {
96467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96468       };
96469     }
96470   }
96471
96472   jresult = (void *)result;
96473   return jresult;
96474 }
96475
96476
96477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
96478   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96479
96480   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96481   {
96482     try {
96483       delete arg1;
96484     } catch (std::out_of_range& e) {
96485       {
96486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96487       };
96488     } catch (std::exception& e) {
96489       {
96490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96491       };
96492     } catch (Dali::DaliException e) {
96493       {
96494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96495       };
96496     } catch (...) {
96497       {
96498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96499       };
96500     }
96501   }
96502
96503 }
96504
96505
96506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
96507   unsigned int jresult ;
96508   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96509   bool result;
96510
96511   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96512   {
96513     try {
96514       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96515     } catch (std::out_of_range& e) {
96516       {
96517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96518       };
96519     } catch (std::exception& e) {
96520       {
96521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96522       };
96523     } catch (Dali::DaliException e) {
96524       {
96525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96526       };
96527     } catch (...) {
96528       {
96529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96530       };
96531     }
96532   }
96533
96534   jresult = result;
96535   return jresult;
96536 }
96537
96538
96539 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
96540   unsigned long jresult ;
96541   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96542   std::size_t result;
96543
96544   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96545   {
96546     try {
96547       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96548     } catch (std::out_of_range& e) {
96549       {
96550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96551       };
96552     } catch (std::exception& e) {
96553       {
96554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96555       };
96556     } catch (Dali::DaliException e) {
96557       {
96558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96559       };
96560     } catch (...) {
96561       {
96562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96563       };
96564     }
96565   }
96566
96567   jresult = (unsigned long)result;
96568   return jresult;
96569 }
96570
96571
96572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
96573   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96574   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96575
96576   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96577   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96578   {
96579     try {
96580       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
96581     } catch (std::out_of_range& e) {
96582       {
96583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96584       };
96585     } catch (std::exception& e) {
96586       {
96587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96588       };
96589     } catch (Dali::DaliException e) {
96590       {
96591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96592       };
96593     } catch (...) {
96594       {
96595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96596       };
96597     }
96598   }
96599
96600 }
96601
96602
96603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96604   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96605   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96606
96607   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96608   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96609   {
96610     try {
96611       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96612     } catch (std::out_of_range& e) {
96613       {
96614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96615       };
96616     } catch (std::exception& e) {
96617       {
96618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96619       };
96620     } catch (Dali::DaliException e) {
96621       {
96622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96623       };
96624     } catch (...) {
96625       {
96626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96627       };
96628     }
96629   }
96630
96631 }
96632
96633
96634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96635   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96636   Dali::Actor arg2 ;
96637   bool arg3 ;
96638   Dali::Actor *argp2 ;
96639
96640   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96641   argp2 = (Dali::Actor *)jarg2;
96642   if (!argp2) {
96643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96644     return ;
96645   }
96646   arg2 = *argp2;
96647   arg3 = jarg3 ? true : false;
96648   {
96649     try {
96650       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96651     } catch (std::out_of_range& e) {
96652       {
96653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96654       };
96655     } catch (std::exception& e) {
96656       {
96657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96658       };
96659     } catch (Dali::DaliException e) {
96660       {
96661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96662       };
96663     } catch (...) {
96664       {
96665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96666       };
96667     }
96668   }
96669
96670 }
96671
96672
96673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96674   void * jresult ;
96675   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96676
96677   {
96678     try {
96679       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96680     } catch (std::out_of_range& e) {
96681       {
96682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96683       };
96684     } catch (std::exception& e) {
96685       {
96686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96687       };
96688     } catch (Dali::DaliException e) {
96689       {
96690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96691       };
96692     } catch (...) {
96693       {
96694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96695       };
96696     }
96697   }
96698
96699   jresult = (void *)result;
96700   return jresult;
96701 }
96702
96703
96704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96705   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96706
96707   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96708   {
96709     try {
96710       delete arg1;
96711     } catch (std::out_of_range& e) {
96712       {
96713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96714       };
96715     } catch (std::exception& e) {
96716       {
96717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96718       };
96719     } catch (Dali::DaliException e) {
96720       {
96721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96722       };
96723     } catch (...) {
96724       {
96725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96726       };
96727     }
96728   }
96729
96730 }
96731
96732
96733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96734   unsigned int jresult ;
96735   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96736   bool result;
96737
96738   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96739   {
96740     try {
96741       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);
96742     } catch (std::out_of_range& e) {
96743       {
96744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96745       };
96746     } catch (std::exception& e) {
96747       {
96748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96749       };
96750     } catch (Dali::DaliException e) {
96751       {
96752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96753       };
96754     } catch (...) {
96755       {
96756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96757       };
96758     }
96759   }
96760
96761   jresult = result;
96762   return jresult;
96763 }
96764
96765
96766 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96767   unsigned long jresult ;
96768   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96769   std::size_t result;
96770
96771   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96772   {
96773     try {
96774       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);
96775     } catch (std::out_of_range& e) {
96776       {
96777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96778       };
96779     } catch (std::exception& e) {
96780       {
96781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96782       };
96783     } catch (Dali::DaliException e) {
96784       {
96785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96786       };
96787     } catch (...) {
96788       {
96789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96790       };
96791     }
96792   }
96793
96794   jresult = (unsigned long)result;
96795   return jresult;
96796 }
96797
96798
96799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96800   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96801   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96802
96803   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96804   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96805   {
96806     try {
96807       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96808     } catch (std::out_of_range& e) {
96809       {
96810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96811       };
96812     } catch (std::exception& e) {
96813       {
96814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96815       };
96816     } catch (Dali::DaliException e) {
96817       {
96818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96819       };
96820     } catch (...) {
96821       {
96822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96823       };
96824     }
96825   }
96826
96827 }
96828
96829
96830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96831   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96832   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96833
96834   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96835   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96836   {
96837     try {
96838       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96839     } catch (std::out_of_range& e) {
96840       {
96841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96842       };
96843     } catch (std::exception& e) {
96844       {
96845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96846       };
96847     } catch (Dali::DaliException e) {
96848       {
96849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96850       };
96851     } catch (...) {
96852       {
96853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96854       };
96855     }
96856   }
96857
96858 }
96859
96860
96861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96862   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96863   Dali::Toolkit::StyleManager arg2 ;
96864   Dali::StyleChange::Type arg3 ;
96865   Dali::Toolkit::StyleManager *argp2 ;
96866
96867   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96868   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96869   if (!argp2) {
96870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96871     return ;
96872   }
96873   arg2 = *argp2;
96874   arg3 = (Dali::StyleChange::Type)jarg3;
96875   {
96876     try {
96877       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96878     } catch (std::out_of_range& e) {
96879       {
96880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96881       };
96882     } catch (std::exception& e) {
96883       {
96884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96885       };
96886     } catch (Dali::DaliException e) {
96887       {
96888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96889       };
96890     } catch (...) {
96891       {
96892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96893       };
96894     }
96895   }
96896
96897 }
96898
96899
96900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96901   void * jresult ;
96902   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96903
96904   {
96905     try {
96906       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96907     } catch (std::out_of_range& e) {
96908       {
96909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96910       };
96911     } catch (std::exception& e) {
96912       {
96913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96914       };
96915     } catch (Dali::DaliException e) {
96916       {
96917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96918       };
96919     } catch (...) {
96920       {
96921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96922       };
96923     }
96924   }
96925
96926   jresult = (void *)result;
96927   return jresult;
96928 }
96929
96930
96931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96932   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96933
96934   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96935   {
96936     try {
96937       delete arg1;
96938     } catch (std::out_of_range& e) {
96939       {
96940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96941       };
96942     } catch (std::exception& e) {
96943       {
96944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96945       };
96946     } catch (Dali::DaliException e) {
96947       {
96948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96949       };
96950     } catch (...) {
96951       {
96952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96953       };
96954     }
96955   }
96956
96957 }
96958
96959
96960 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96961   unsigned int jresult ;
96962   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96963   bool result;
96964
96965   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96966   {
96967     try {
96968       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96969     } catch (std::out_of_range& e) {
96970       {
96971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96972       };
96973     } catch (std::exception& e) {
96974       {
96975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96976       };
96977     } catch (Dali::DaliException e) {
96978       {
96979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96980       };
96981     } catch (...) {
96982       {
96983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96984       };
96985     }
96986   }
96987
96988   jresult = result;
96989   return jresult;
96990 }
96991
96992
96993 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96994   unsigned long jresult ;
96995   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96996   std::size_t result;
96997
96998   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96999   {
97000     try {
97001       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
97002     } catch (std::out_of_range& e) {
97003       {
97004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97005       };
97006     } catch (std::exception& e) {
97007       {
97008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97009       };
97010     } catch (Dali::DaliException e) {
97011       {
97012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97013       };
97014     } catch (...) {
97015       {
97016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97017       };
97018     }
97019   }
97020
97021   jresult = (unsigned long)result;
97022   return jresult;
97023 }
97024
97025
97026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
97027   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97028   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
97029
97030   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97031   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
97032   {
97033     try {
97034       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
97035     } catch (std::out_of_range& e) {
97036       {
97037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97038       };
97039     } catch (std::exception& e) {
97040       {
97041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97042       };
97043     } catch (Dali::DaliException e) {
97044       {
97045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97046       };
97047     } catch (...) {
97048       {
97049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97050       };
97051     }
97052   }
97053
97054 }
97055
97056
97057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
97058   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97059   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
97060
97061   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97062   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
97063   {
97064     try {
97065       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
97066     } catch (std::out_of_range& e) {
97067       {
97068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97069       };
97070     } catch (std::exception& e) {
97071       {
97072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97073       };
97074     } catch (Dali::DaliException e) {
97075       {
97076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97077       };
97078     } catch (...) {
97079       {
97080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97081       };
97082     }
97083   }
97084
97085 }
97086
97087
97088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
97089   unsigned int jresult ;
97090   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97091   Dali::Toolkit::Button arg2 ;
97092   Dali::Toolkit::Button *argp2 ;
97093   bool result;
97094
97095   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97096   argp2 = (Dali::Toolkit::Button *)jarg2;
97097   if (!argp2) {
97098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
97099     return 0;
97100   }
97101   arg2 = *argp2;
97102   {
97103     try {
97104       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
97105     } catch (std::out_of_range& e) {
97106       {
97107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97108       };
97109     } catch (std::exception& e) {
97110       {
97111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97112       };
97113     } catch (Dali::DaliException e) {
97114       {
97115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97116       };
97117     } catch (...) {
97118       {
97119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97120       };
97121     }
97122   }
97123
97124   jresult = result;
97125   return jresult;
97126 }
97127
97128
97129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
97130   void * jresult ;
97131   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
97132
97133   {
97134     try {
97135       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
97136     } catch (std::out_of_range& e) {
97137       {
97138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97139       };
97140     } catch (std::exception& e) {
97141       {
97142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97143       };
97144     } catch (Dali::DaliException e) {
97145       {
97146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97147       };
97148     } catch (...) {
97149       {
97150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97151       };
97152     }
97153   }
97154
97155   jresult = (void *)result;
97156   return jresult;
97157 }
97158
97159
97160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
97161   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97162
97163   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97164   {
97165     try {
97166       delete arg1;
97167     } catch (std::out_of_range& e) {
97168       {
97169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97170       };
97171     } catch (std::exception& e) {
97172       {
97173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97174       };
97175     } catch (Dali::DaliException e) {
97176       {
97177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97178       };
97179     } catch (...) {
97180       {
97181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97182       };
97183     }
97184   }
97185
97186 }
97187
97188
97189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
97190   unsigned int jresult ;
97191   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97192   bool result;
97193
97194   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97195   {
97196     try {
97197       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97198     } catch (std::out_of_range& e) {
97199       {
97200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97201       };
97202     } catch (std::exception& e) {
97203       {
97204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97205       };
97206     } catch (Dali::DaliException e) {
97207       {
97208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97209       };
97210     } catch (...) {
97211       {
97212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97213       };
97214     }
97215   }
97216
97217   jresult = result;
97218   return jresult;
97219 }
97220
97221
97222 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
97223   unsigned long jresult ;
97224   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97225   std::size_t result;
97226
97227   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97228   {
97229     try {
97230       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97231     } catch (std::out_of_range& e) {
97232       {
97233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97234       };
97235     } catch (std::exception& e) {
97236       {
97237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97238       };
97239     } catch (Dali::DaliException e) {
97240       {
97241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97242       };
97243     } catch (...) {
97244       {
97245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97246       };
97247     }
97248   }
97249
97250   jresult = (unsigned long)result;
97251   return jresult;
97252 }
97253
97254
97255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
97256   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97257   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97258
97259   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97260   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97261   {
97262     try {
97263       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
97264     } catch (std::out_of_range& e) {
97265       {
97266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97267       };
97268     } catch (std::exception& e) {
97269       {
97270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97271       };
97272     } catch (Dali::DaliException e) {
97273       {
97274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97275       };
97276     } catch (...) {
97277       {
97278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97279       };
97280     }
97281   }
97282
97283 }
97284
97285
97286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
97287   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97288   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97289
97290   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97291   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97292   {
97293     try {
97294       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
97295     } catch (std::out_of_range& e) {
97296       {
97297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97298       };
97299     } catch (std::exception& e) {
97300       {
97301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97302       };
97303     } catch (Dali::DaliException e) {
97304       {
97305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97306       };
97307     } catch (...) {
97308       {
97309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97310       };
97311     }
97312   }
97313
97314 }
97315
97316
97317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
97318   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97319   Dali::Toolkit::GaussianBlurView arg2 ;
97320   Dali::Toolkit::GaussianBlurView *argp2 ;
97321
97322   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97323   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
97324   if (!argp2) {
97325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
97326     return ;
97327   }
97328   arg2 = *argp2;
97329   {
97330     try {
97331       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(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_new_GaussianBlurViewSignal() {
97355   void * jresult ;
97356   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
97357
97358   {
97359     try {
97360       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
97361     } catch (std::out_of_range& e) {
97362       {
97363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97364       };
97365     } catch (std::exception& e) {
97366       {
97367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97368       };
97369     } catch (Dali::DaliException e) {
97370       {
97371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97372       };
97373     } catch (...) {
97374       {
97375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97376       };
97377     }
97378   }
97379
97380   jresult = (void *)result;
97381   return jresult;
97382 }
97383
97384
97385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
97386   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97387
97388   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97389   {
97390     try {
97391       delete arg1;
97392     } catch (std::out_of_range& e) {
97393       {
97394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97395       };
97396     } catch (std::exception& e) {
97397       {
97398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97399       };
97400     } catch (Dali::DaliException e) {
97401       {
97402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97403       };
97404     } catch (...) {
97405       {
97406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97407       };
97408     }
97409   }
97410
97411 }
97412
97413
97414 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
97415   unsigned int jresult ;
97416   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97417   bool result;
97418
97419   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97420   {
97421     try {
97422       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);
97423     } catch (std::out_of_range& e) {
97424       {
97425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97426       };
97427     } catch (std::exception& e) {
97428       {
97429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97430       };
97431     } catch (Dali::DaliException e) {
97432       {
97433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97434       };
97435     } catch (...) {
97436       {
97437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97438       };
97439     }
97440   }
97441
97442   jresult = result;
97443   return jresult;
97444 }
97445
97446
97447 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
97448   unsigned long jresult ;
97449   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97450   std::size_t result;
97451
97452   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97453   {
97454     try {
97455       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);
97456     } catch (std::out_of_range& e) {
97457       {
97458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97459       };
97460     } catch (std::exception& e) {
97461       {
97462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97463       };
97464     } catch (Dali::DaliException e) {
97465       {
97466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97467       };
97468     } catch (...) {
97469       {
97470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97471       };
97472     }
97473   }
97474
97475   jresult = (unsigned long)result;
97476   return jresult;
97477 }
97478
97479
97480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
97481   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97482   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97483
97484   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97485   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97486   {
97487     try {
97488       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
97489     } catch (std::out_of_range& e) {
97490       {
97491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97492       };
97493     } catch (std::exception& e) {
97494       {
97495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97496       };
97497     } catch (Dali::DaliException e) {
97498       {
97499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97500       };
97501     } catch (...) {
97502       {
97503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97504       };
97505     }
97506   }
97507
97508 }
97509
97510
97511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
97512   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97513   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97514
97515   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97516   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97517   {
97518     try {
97519       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
97520     } catch (std::out_of_range& e) {
97521       {
97522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97523       };
97524     } catch (std::exception& e) {
97525       {
97526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97527       };
97528     } catch (Dali::DaliException e) {
97529       {
97530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97531       };
97532     } catch (...) {
97533       {
97534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97535       };
97536     }
97537   }
97538
97539 }
97540
97541
97542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
97543   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97544   Dali::Toolkit::PageTurnView arg2 ;
97545   unsigned int arg3 ;
97546   bool arg4 ;
97547   Dali::Toolkit::PageTurnView *argp2 ;
97548
97549   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97550   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97551   if (!argp2) {
97552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97553     return ;
97554   }
97555   arg2 = *argp2;
97556   arg3 = (unsigned int)jarg3;
97557   arg4 = jarg4 ? true : false;
97558   {
97559     try {
97560       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97561     } catch (std::out_of_range& e) {
97562       {
97563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97564       };
97565     } catch (std::exception& e) {
97566       {
97567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97568       };
97569     } catch (Dali::DaliException e) {
97570       {
97571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97572       };
97573     } catch (...) {
97574       {
97575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97576       };
97577     }
97578   }
97579
97580 }
97581
97582
97583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
97584   void * jresult ;
97585   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
97586
97587   {
97588     try {
97589       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
97590     } catch (std::out_of_range& e) {
97591       {
97592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97593       };
97594     } catch (std::exception& e) {
97595       {
97596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97597       };
97598     } catch (Dali::DaliException e) {
97599       {
97600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97601       };
97602     } catch (...) {
97603       {
97604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97605       };
97606     }
97607   }
97608
97609   jresult = (void *)result;
97610   return jresult;
97611 }
97612
97613
97614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97615   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97616
97617   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97618   {
97619     try {
97620       delete arg1;
97621     } catch (std::out_of_range& e) {
97622       {
97623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97624       };
97625     } catch (std::exception& e) {
97626       {
97627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97628       };
97629     } catch (Dali::DaliException e) {
97630       {
97631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97632       };
97633     } catch (...) {
97634       {
97635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97636       };
97637     }
97638   }
97639
97640 }
97641
97642
97643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97644   unsigned int jresult ;
97645   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97646   bool result;
97647
97648   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97649   {
97650     try {
97651       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97652     } catch (std::out_of_range& e) {
97653       {
97654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97655       };
97656     } catch (std::exception& e) {
97657       {
97658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97659       };
97660     } catch (Dali::DaliException e) {
97661       {
97662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97663       };
97664     } catch (...) {
97665       {
97666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97667       };
97668     }
97669   }
97670
97671   jresult = result;
97672   return jresult;
97673 }
97674
97675
97676 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97677   unsigned long jresult ;
97678   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97679   std::size_t result;
97680
97681   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97682   {
97683     try {
97684       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97685     } catch (std::out_of_range& e) {
97686       {
97687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97688       };
97689     } catch (std::exception& e) {
97690       {
97691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97692       };
97693     } catch (Dali::DaliException e) {
97694       {
97695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97696       };
97697     } catch (...) {
97698       {
97699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97700       };
97701     }
97702   }
97703
97704   jresult = (unsigned long)result;
97705   return jresult;
97706 }
97707
97708
97709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97710   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97711   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97712
97713   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97714   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97715   {
97716     try {
97717       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97718     } catch (std::out_of_range& e) {
97719       {
97720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97721       };
97722     } catch (std::exception& e) {
97723       {
97724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97725       };
97726     } catch (Dali::DaliException e) {
97727       {
97728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97729       };
97730     } catch (...) {
97731       {
97732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97733       };
97734     }
97735   }
97736
97737 }
97738
97739
97740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97741   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97742   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97743
97744   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97745   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97746   {
97747     try {
97748       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97749     } catch (std::out_of_range& e) {
97750       {
97751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97752       };
97753     } catch (std::exception& e) {
97754       {
97755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97756       };
97757     } catch (Dali::DaliException e) {
97758       {
97759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97760       };
97761     } catch (...) {
97762       {
97763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97764       };
97765     }
97766   }
97767
97768 }
97769
97770
97771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97772   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97773   Dali::Toolkit::PageTurnView arg2 ;
97774   Dali::Toolkit::PageTurnView *argp2 ;
97775
97776   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97777   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97778   if (!argp2) {
97779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97780     return ;
97781   }
97782   arg2 = *argp2;
97783   {
97784     try {
97785       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(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_new_PagePanSignal() {
97809   void * jresult ;
97810   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97811
97812   {
97813     try {
97814       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97815     } catch (std::out_of_range& e) {
97816       {
97817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97818       };
97819     } catch (std::exception& e) {
97820       {
97821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97822       };
97823     } catch (Dali::DaliException e) {
97824       {
97825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97826       };
97827     } catch (...) {
97828       {
97829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97830       };
97831     }
97832   }
97833
97834   jresult = (void *)result;
97835   return jresult;
97836 }
97837
97838
97839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97840   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97841
97842   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97843   {
97844     try {
97845       delete arg1;
97846     } catch (std::out_of_range& e) {
97847       {
97848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97849       };
97850     } catch (std::exception& e) {
97851       {
97852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97853       };
97854     } catch (Dali::DaliException e) {
97855       {
97856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97857       };
97858     } catch (...) {
97859       {
97860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97861       };
97862     }
97863   }
97864
97865 }
97866
97867
97868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97869   unsigned int jresult ;
97870   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97871   bool result;
97872
97873   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97874   {
97875     try {
97876       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);
97877     } catch (std::out_of_range& e) {
97878       {
97879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97880       };
97881     } catch (std::exception& e) {
97882       {
97883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97884       };
97885     } catch (Dali::DaliException e) {
97886       {
97887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97888       };
97889     } catch (...) {
97890       {
97891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97892       };
97893     }
97894   }
97895
97896   jresult = result;
97897   return jresult;
97898 }
97899
97900
97901 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97902   unsigned long jresult ;
97903   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97904   std::size_t result;
97905
97906   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97907   {
97908     try {
97909       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);
97910     } catch (std::out_of_range& e) {
97911       {
97912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97913       };
97914     } catch (std::exception& e) {
97915       {
97916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97917       };
97918     } catch (Dali::DaliException e) {
97919       {
97920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97921       };
97922     } catch (...) {
97923       {
97924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97925       };
97926     }
97927   }
97928
97929   jresult = (unsigned long)result;
97930   return jresult;
97931 }
97932
97933
97934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97935   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97936   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97937
97938   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97939   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97940   {
97941     try {
97942       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97943     } catch (std::out_of_range& e) {
97944       {
97945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97946       };
97947     } catch (std::exception& e) {
97948       {
97949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97950       };
97951     } catch (Dali::DaliException e) {
97952       {
97953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97954       };
97955     } catch (...) {
97956       {
97957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97958       };
97959     }
97960   }
97961
97962 }
97963
97964
97965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97966   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97967   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97968
97969   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97970   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97971   {
97972     try {
97973       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97974     } catch (std::out_of_range& e) {
97975       {
97976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97977       };
97978     } catch (std::exception& e) {
97979       {
97980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97981       };
97982     } catch (Dali::DaliException e) {
97983       {
97984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97985       };
97986     } catch (...) {
97987       {
97988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97989       };
97990     }
97991   }
97992
97993 }
97994
97995
97996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97997   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97998   Dali::Toolkit::ProgressBar arg2 ;
97999   float arg3 ;
98000   float arg4 ;
98001   Dali::Toolkit::ProgressBar *argp2 ;
98002
98003   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
98004   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
98005   if (!argp2) {
98006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
98007     return ;
98008   }
98009   arg2 = *argp2;
98010   arg3 = (float)jarg3;
98011   arg4 = (float)jarg4;
98012   {
98013     try {
98014       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
98015     } catch (std::out_of_range& e) {
98016       {
98017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98018       };
98019     } catch (std::exception& e) {
98020       {
98021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98022       };
98023     } catch (Dali::DaliException e) {
98024       {
98025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98026       };
98027     } catch (...) {
98028       {
98029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98030       };
98031     }
98032   }
98033
98034 }
98035
98036
98037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
98038   void * jresult ;
98039   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
98040
98041   {
98042     try {
98043       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
98044     } catch (std::out_of_range& e) {
98045       {
98046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98047       };
98048     } catch (std::exception& e) {
98049       {
98050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98051       };
98052     } catch (Dali::DaliException e) {
98053       {
98054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98055       };
98056     } catch (...) {
98057       {
98058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98059       };
98060     }
98061   }
98062
98063   jresult = (void *)result;
98064   return jresult;
98065 }
98066
98067
98068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
98069   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
98070
98071   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
98072   {
98073     try {
98074       delete arg1;
98075     } catch (std::out_of_range& e) {
98076       {
98077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98078       };
98079     } catch (std::exception& e) {
98080       {
98081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98082       };
98083     } catch (Dali::DaliException e) {
98084       {
98085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98086       };
98087     } catch (...) {
98088       {
98089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98090       };
98091     }
98092   }
98093
98094 }
98095
98096
98097 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
98098   unsigned int jresult ;
98099   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98100   bool result;
98101
98102   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98103   {
98104     try {
98105       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);
98106     } catch (std::out_of_range& e) {
98107       {
98108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98109       };
98110     } catch (std::exception& e) {
98111       {
98112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98113       };
98114     } catch (Dali::DaliException e) {
98115       {
98116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98117       };
98118     } catch (...) {
98119       {
98120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98121       };
98122     }
98123   }
98124
98125   jresult = result;
98126   return jresult;
98127 }
98128
98129
98130 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
98131   unsigned long jresult ;
98132   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98133   std::size_t result;
98134
98135   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98136   {
98137     try {
98138       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);
98139     } catch (std::out_of_range& e) {
98140       {
98141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98142       };
98143     } catch (std::exception& e) {
98144       {
98145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98146       };
98147     } catch (Dali::DaliException e) {
98148       {
98149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98150       };
98151     } catch (...) {
98152       {
98153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98154       };
98155     }
98156   }
98157
98158   jresult = (unsigned long)result;
98159   return jresult;
98160 }
98161
98162
98163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
98164   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98165   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98166
98167   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98168   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98169   {
98170     try {
98171       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98172     } catch (std::out_of_range& e) {
98173       {
98174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98175       };
98176     } catch (std::exception& e) {
98177       {
98178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98179       };
98180     } catch (Dali::DaliException e) {
98181       {
98182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98183       };
98184     } catch (...) {
98185       {
98186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98187       };
98188     }
98189   }
98190
98191 }
98192
98193
98194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
98195   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98196   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98197
98198   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98199   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98200   {
98201     try {
98202       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98203     } catch (std::out_of_range& e) {
98204       {
98205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98206       };
98207     } catch (std::exception& e) {
98208       {
98209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98210       };
98211     } catch (Dali::DaliException e) {
98212       {
98213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98214       };
98215     } catch (...) {
98216       {
98217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98218       };
98219     }
98220   }
98221
98222 }
98223
98224
98225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
98226   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98227   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
98228
98229   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98230   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
98231   if (!arg2) {
98232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
98233     return ;
98234   }
98235   {
98236     try {
98237       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
98238     } catch (std::out_of_range& e) {
98239       {
98240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98241       };
98242     } catch (std::exception& e) {
98243       {
98244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98245       };
98246     } catch (Dali::DaliException e) {
98247       {
98248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98249       };
98250     } catch (...) {
98251       {
98252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98253       };
98254     }
98255   }
98256
98257 }
98258
98259
98260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
98261   void * jresult ;
98262   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
98263
98264   {
98265     try {
98266       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
98267     } catch (std::out_of_range& e) {
98268       {
98269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98270       };
98271     } catch (std::exception& e) {
98272       {
98273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98274       };
98275     } catch (Dali::DaliException e) {
98276       {
98277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98278       };
98279     } catch (...) {
98280       {
98281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98282       };
98283     }
98284   }
98285
98286   jresult = (void *)result;
98287   return jresult;
98288 }
98289
98290
98291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
98292   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98293
98294   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98295   {
98296     try {
98297       delete arg1;
98298     } catch (std::out_of_range& e) {
98299       {
98300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98301       };
98302     } catch (std::exception& e) {
98303       {
98304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98305       };
98306     } catch (Dali::DaliException e) {
98307       {
98308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98309       };
98310     } catch (...) {
98311       {
98312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98313       };
98314     }
98315   }
98316
98317 }
98318
98319
98320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
98321   unsigned int jresult ;
98322   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98323   bool result;
98324
98325   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98326   {
98327     try {
98328       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98329     } catch (std::out_of_range& e) {
98330       {
98331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98332       };
98333     } catch (std::exception& e) {
98334       {
98335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98336       };
98337     } catch (Dali::DaliException e) {
98338       {
98339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98340       };
98341     } catch (...) {
98342       {
98343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98344       };
98345     }
98346   }
98347
98348   jresult = result;
98349   return jresult;
98350 }
98351
98352
98353 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
98354   unsigned long jresult ;
98355   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98356   std::size_t result;
98357
98358   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98359   {
98360     try {
98361       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98362     } catch (std::out_of_range& e) {
98363       {
98364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98365       };
98366     } catch (std::exception& e) {
98367       {
98368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98369       };
98370     } catch (Dali::DaliException e) {
98371       {
98372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98373       };
98374     } catch (...) {
98375       {
98376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98377       };
98378     }
98379   }
98380
98381   jresult = (unsigned long)result;
98382   return jresult;
98383 }
98384
98385
98386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
98387   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98388   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98389
98390   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98391   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98392   {
98393     try {
98394       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98395     } catch (std::out_of_range& e) {
98396       {
98397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98398       };
98399     } catch (std::exception& e) {
98400       {
98401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98402       };
98403     } catch (Dali::DaliException e) {
98404       {
98405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98406       };
98407     } catch (...) {
98408       {
98409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98410       };
98411     }
98412   }
98413
98414 }
98415
98416
98417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
98418   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98419   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98420
98421   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98422   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98423   {
98424     try {
98425       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98426     } catch (std::out_of_range& e) {
98427       {
98428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98429       };
98430     } catch (std::exception& e) {
98431       {
98432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98433       };
98434     } catch (Dali::DaliException e) {
98435       {
98436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98437       };
98438     } catch (...) {
98439       {
98440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98441       };
98442     }
98443   }
98444
98445 }
98446
98447
98448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
98449   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98450   Dali::Vector2 *arg2 = 0 ;
98451
98452   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98453   arg2 = (Dali::Vector2 *)jarg2;
98454   if (!arg2) {
98455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
98456     return ;
98457   }
98458   {
98459     try {
98460       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
98461     } catch (std::out_of_range& e) {
98462       {
98463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98464       };
98465     } catch (std::exception& e) {
98466       {
98467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98468       };
98469     } catch (Dali::DaliException e) {
98470       {
98471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98472       };
98473     } catch (...) {
98474       {
98475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98476       };
98477     }
98478   }
98479
98480 }
98481
98482
98483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
98484   void * jresult ;
98485   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
98486
98487   {
98488     try {
98489       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
98490     } catch (std::out_of_range& e) {
98491       {
98492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98493       };
98494     } catch (std::exception& e) {
98495       {
98496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98497       };
98498     } catch (Dali::DaliException e) {
98499       {
98500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98501       };
98502     } catch (...) {
98503       {
98504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98505       };
98506     }
98507   }
98508
98509   jresult = (void *)result;
98510   return jresult;
98511 }
98512
98513
98514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
98515   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98516
98517   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98518   {
98519     try {
98520       delete arg1;
98521     } catch (std::out_of_range& e) {
98522       {
98523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98524       };
98525     } catch (std::exception& e) {
98526       {
98527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98528       };
98529     } catch (Dali::DaliException e) {
98530       {
98531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98532       };
98533     } catch (...) {
98534       {
98535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98536       };
98537     }
98538   }
98539
98540 }
98541
98542
98543
98544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
98545   unsigned int jresult ;
98546   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98547   bool result;
98548
98549   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98550   {
98551     try {
98552       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);
98553     } catch (std::out_of_range& e) {
98554       {
98555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98556       };
98557     } catch (std::exception& e) {
98558       {
98559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98560       };
98561     } catch (Dali::DaliException e) {
98562       {
98563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98564       };
98565     } catch (...) {
98566       {
98567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98568       };
98569     }
98570   }
98571
98572   jresult = result;
98573   return jresult;
98574 }
98575
98576
98577 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
98578   unsigned long jresult ;
98579   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98580   std::size_t result;
98581
98582   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98583   {
98584     try {
98585       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);
98586     } catch (std::out_of_range& e) {
98587       {
98588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98589       };
98590     } catch (std::exception& e) {
98591       {
98592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98593       };
98594     } catch (Dali::DaliException e) {
98595       {
98596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98597       };
98598     } catch (...) {
98599       {
98600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98601       };
98602     }
98603   }
98604
98605   jresult = (unsigned long)result;
98606   return jresult;
98607 }
98608
98609
98610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
98611   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98612   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98613
98614   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98615   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98616   {
98617     try {
98618       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98619     } catch (std::out_of_range& e) {
98620       {
98621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98622       };
98623     } catch (std::exception& e) {
98624       {
98625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98626       };
98627     } catch (Dali::DaliException e) {
98628       {
98629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98630       };
98631     } catch (...) {
98632       {
98633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98634       };
98635     }
98636   }
98637
98638 }
98639
98640
98641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98642   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98643   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98644
98645   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98646   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98647   {
98648     try {
98649       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98650     } catch (std::out_of_range& e) {
98651       {
98652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98653       };
98654     } catch (std::exception& e) {
98655       {
98656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98657       };
98658     } catch (Dali::DaliException e) {
98659       {
98660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98661       };
98662     } catch (...) {
98663       {
98664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98665       };
98666     }
98667   }
98668
98669 }
98670
98671
98672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98673   unsigned int jresult ;
98674   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98675   Dali::Toolkit::Control arg2 ;
98676   Dali::KeyEvent *arg3 = 0 ;
98677   Dali::Toolkit::Control *argp2 ;
98678   bool result;
98679
98680   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98681   argp2 = (Dali::Toolkit::Control *)jarg2;
98682   if (!argp2) {
98683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98684     return 0;
98685   }
98686   arg2 = *argp2;
98687   arg3 = (Dali::KeyEvent *)jarg3;
98688   if (!arg3) {
98689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98690     return 0;
98691   }
98692   {
98693     try {
98694       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);
98695     } catch (std::out_of_range& e) {
98696       {
98697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98698       };
98699     } catch (std::exception& e) {
98700       {
98701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98702       };
98703     } catch (Dali::DaliException e) {
98704       {
98705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98706       };
98707     } catch (...) {
98708       {
98709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98710       };
98711     }
98712   }
98713
98714   jresult = result;
98715   return jresult;
98716 }
98717
98718
98719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98720   void * jresult ;
98721   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98722
98723   {
98724     try {
98725       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98726     } catch (std::out_of_range& e) {
98727       {
98728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98729       };
98730     } catch (std::exception& e) {
98731       {
98732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98733       };
98734     } catch (Dali::DaliException e) {
98735       {
98736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98737       };
98738     } catch (...) {
98739       {
98740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98741       };
98742     }
98743   }
98744
98745   jresult = (void *)result;
98746   return jresult;
98747 }
98748
98749
98750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98751   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98752
98753   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98754   {
98755     try {
98756       delete arg1;
98757     } catch (std::out_of_range& e) {
98758       {
98759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98760       };
98761     } catch (std::exception& e) {
98762       {
98763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98764       };
98765     } catch (Dali::DaliException e) {
98766       {
98767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98768       };
98769     } catch (...) {
98770       {
98771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98772       };
98773     }
98774   }
98775
98776 }
98777
98778
98779 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98780   unsigned int jresult ;
98781   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98782   bool result;
98783
98784   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98785   {
98786     try {
98787       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98788     } catch (std::out_of_range& e) {
98789       {
98790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98791       };
98792     } catch (std::exception& e) {
98793       {
98794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98795       };
98796     } catch (Dali::DaliException e) {
98797       {
98798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98799       };
98800     } catch (...) {
98801       {
98802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98803       };
98804     }
98805   }
98806
98807   jresult = result;
98808   return jresult;
98809 }
98810
98811
98812 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98813   unsigned long jresult ;
98814   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98815   std::size_t result;
98816
98817   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98818   {
98819     try {
98820       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98821     } catch (std::out_of_range& e) {
98822       {
98823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98824       };
98825     } catch (std::exception& e) {
98826       {
98827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98828       };
98829     } catch (Dali::DaliException e) {
98830       {
98831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98832       };
98833     } catch (...) {
98834       {
98835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98836       };
98837     }
98838   }
98839
98840   jresult = (unsigned long)result;
98841   return jresult;
98842 }
98843
98844
98845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98846   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98847   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98848
98849   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98850   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98851   {
98852     try {
98853       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98854     } catch (std::out_of_range& e) {
98855       {
98856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98857       };
98858     } catch (std::exception& e) {
98859       {
98860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98861       };
98862     } catch (Dali::DaliException e) {
98863       {
98864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98865       };
98866     } catch (...) {
98867       {
98868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98869       };
98870     }
98871   }
98872
98873 }
98874
98875
98876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98877   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98878   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98879
98880   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98881   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98882   {
98883     try {
98884       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98885     } catch (std::out_of_range& e) {
98886       {
98887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98888       };
98889     } catch (std::exception& e) {
98890       {
98891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98892       };
98893     } catch (Dali::DaliException e) {
98894       {
98895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98896       };
98897     } catch (...) {
98898       {
98899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98900       };
98901     }
98902   }
98903
98904 }
98905
98906
98907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98908   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98909   Dali::Toolkit::Control arg2 ;
98910   Dali::Toolkit::Control *argp2 ;
98911
98912   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98913   argp2 = (Dali::Toolkit::Control *)jarg2;
98914   if (!argp2) {
98915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98916     return ;
98917   }
98918   arg2 = *argp2;
98919   {
98920     try {
98921       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(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_new_KeyInputFocusSignal() {
98945   void * jresult ;
98946   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98947
98948   {
98949     try {
98950       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98951     } catch (std::out_of_range& e) {
98952       {
98953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98954       };
98955     } catch (std::exception& e) {
98956       {
98957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98958       };
98959     } catch (Dali::DaliException e) {
98960       {
98961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98962       };
98963     } catch (...) {
98964       {
98965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98966       };
98967     }
98968   }
98969
98970   jresult = (void *)result;
98971   return jresult;
98972 }
98973
98974
98975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98976   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98977
98978   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98979   {
98980     try {
98981       delete arg1;
98982     } catch (std::out_of_range& e) {
98983       {
98984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98985       };
98986     } catch (std::exception& e) {
98987       {
98988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98989       };
98990     } catch (Dali::DaliException e) {
98991       {
98992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98993       };
98994     } catch (...) {
98995       {
98996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98997       };
98998     }
98999   }
99000
99001 }
99002
99003
99004 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
99005   unsigned int jresult ;
99006   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99007   bool result;
99008
99009   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99010   {
99011     try {
99012       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
99013     } catch (std::out_of_range& e) {
99014       {
99015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99016       };
99017     } catch (std::exception& e) {
99018       {
99019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99020       };
99021     } catch (Dali::DaliException e) {
99022       {
99023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99024       };
99025     } catch (...) {
99026       {
99027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99028       };
99029     }
99030   }
99031
99032   jresult = result;
99033   return jresult;
99034 }
99035
99036
99037 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
99038   unsigned long jresult ;
99039   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99040   std::size_t result;
99041
99042   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99043   {
99044     try {
99045       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
99046     } catch (std::out_of_range& e) {
99047       {
99048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99049       };
99050     } catch (std::exception& e) {
99051       {
99052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99053       };
99054     } catch (Dali::DaliException e) {
99055       {
99056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99057       };
99058     } catch (...) {
99059       {
99060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99061       };
99062     }
99063   }
99064
99065   jresult = (unsigned long)result;
99066   return jresult;
99067 }
99068
99069
99070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
99071   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99072   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
99073
99074   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99075   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
99076   {
99077     try {
99078       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
99079     } catch (std::out_of_range& e) {
99080       {
99081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99082       };
99083     } catch (std::exception& e) {
99084       {
99085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99086       };
99087     } catch (Dali::DaliException e) {
99088       {
99089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99090       };
99091     } catch (...) {
99092       {
99093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99094       };
99095     }
99096   }
99097
99098 }
99099
99100
99101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
99102   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99103   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
99104
99105   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99106   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
99107   {
99108     try {
99109       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
99110     } catch (std::out_of_range& e) {
99111       {
99112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99113       };
99114     } catch (std::exception& e) {
99115       {
99116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99117       };
99118     } catch (Dali::DaliException e) {
99119       {
99120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99121       };
99122     } catch (...) {
99123       {
99124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99125       };
99126     }
99127   }
99128
99129 }
99130
99131
99132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
99133   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99134   Dali::Toolkit::VideoView *arg2 = 0 ;
99135
99136   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99137   arg2 = (Dali::Toolkit::VideoView *)jarg2;
99138   if (!arg2) {
99139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
99140     return ;
99141   }
99142   {
99143     try {
99144       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
99145     } catch (std::out_of_range& e) {
99146       {
99147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99148       };
99149     } catch (std::exception& e) {
99150       {
99151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99152       };
99153     } catch (Dali::DaliException e) {
99154       {
99155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99156       };
99157     } catch (...) {
99158       {
99159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99160       };
99161     }
99162   }
99163
99164 }
99165
99166
99167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
99168   void * jresult ;
99169   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
99170
99171   {
99172     try {
99173       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
99174     } catch (std::out_of_range& e) {
99175       {
99176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99177       };
99178     } catch (std::exception& e) {
99179       {
99180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99181       };
99182     } catch (Dali::DaliException e) {
99183       {
99184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99185       };
99186     } catch (...) {
99187       {
99188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99189       };
99190     }
99191   }
99192
99193   jresult = (void *)result;
99194   return jresult;
99195 }
99196
99197
99198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
99199   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99200
99201   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99202   {
99203     try {
99204       delete arg1;
99205     } catch (std::out_of_range& e) {
99206       {
99207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99208       };
99209     } catch (std::exception& e) {
99210       {
99211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99212       };
99213     } catch (Dali::DaliException e) {
99214       {
99215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99216       };
99217     } catch (...) {
99218       {
99219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99220       };
99221     }
99222   }
99223
99224 }
99225
99226
99227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
99228   unsigned int jresult ;
99229   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99230   bool result;
99231
99232   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99233   {
99234     try {
99235       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99236     } catch (std::out_of_range& e) {
99237       {
99238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99239       };
99240     } catch (std::exception& e) {
99241       {
99242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99243       };
99244     } catch (Dali::DaliException e) {
99245       {
99246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99247       };
99248     } catch (...) {
99249       {
99250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99251       };
99252     }
99253   }
99254
99255   jresult = result;
99256   return jresult;
99257 }
99258
99259
99260 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
99261   unsigned long jresult ;
99262   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99263   std::size_t result;
99264
99265   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99266   {
99267     try {
99268       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99269     } catch (std::out_of_range& e) {
99270       {
99271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99272       };
99273     } catch (std::exception& e) {
99274       {
99275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99276       };
99277     } catch (Dali::DaliException e) {
99278       {
99279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99280       };
99281     } catch (...) {
99282       {
99283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99284       };
99285     }
99286   }
99287
99288   jresult = (unsigned long)result;
99289   return jresult;
99290 }
99291
99292
99293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
99294   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99295   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99296
99297   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99298   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99299   {
99300     try {
99301       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
99302     } catch (std::out_of_range& e) {
99303       {
99304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99305       };
99306     } catch (std::exception& e) {
99307       {
99308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99309       };
99310     } catch (Dali::DaliException e) {
99311       {
99312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99313       };
99314     } catch (...) {
99315       {
99316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99317       };
99318     }
99319   }
99320
99321 }
99322
99323
99324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
99325   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99326   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99327
99328   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99329   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99330   {
99331     try {
99332       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
99333     } catch (std::out_of_range& e) {
99334       {
99335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99336       };
99337     } catch (std::exception& e) {
99338       {
99339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99340       };
99341     } catch (Dali::DaliException e) {
99342       {
99343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99344       };
99345     } catch (...) {
99346       {
99347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99348       };
99349     }
99350   }
99351
99352 }
99353
99354
99355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
99356   unsigned int jresult ;
99357   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99358   Dali::Toolkit::Slider arg2 ;
99359   float arg3 ;
99360   Dali::Toolkit::Slider *argp2 ;
99361   bool result;
99362
99363   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99364   argp2 = (Dali::Toolkit::Slider *)jarg2;
99365   if (!argp2) {
99366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99367     return 0;
99368   }
99369   arg2 = *argp2;
99370   arg3 = (float)jarg3;
99371   {
99372     try {
99373       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
99374     } catch (std::out_of_range& e) {
99375       {
99376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99377       };
99378     } catch (std::exception& e) {
99379       {
99380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99381       };
99382     } catch (Dali::DaliException e) {
99383       {
99384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99385       };
99386     } catch (...) {
99387       {
99388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99389       };
99390     }
99391   }
99392
99393   jresult = result;
99394   return jresult;
99395 }
99396
99397
99398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
99399   void * jresult ;
99400   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
99401
99402   {
99403     try {
99404       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
99405     } catch (std::out_of_range& e) {
99406       {
99407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99408       };
99409     } catch (std::exception& e) {
99410       {
99411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99412       };
99413     } catch (Dali::DaliException e) {
99414       {
99415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99416       };
99417     } catch (...) {
99418       {
99419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99420       };
99421     }
99422   }
99423
99424   jresult = (void *)result;
99425   return jresult;
99426 }
99427
99428
99429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
99430   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99431
99432   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99433   {
99434     try {
99435       delete arg1;
99436     } catch (std::out_of_range& e) {
99437       {
99438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99439       };
99440     } catch (std::exception& e) {
99441       {
99442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99443       };
99444     } catch (Dali::DaliException e) {
99445       {
99446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99447       };
99448     } catch (...) {
99449       {
99450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99451       };
99452     }
99453   }
99454
99455 }
99456
99457
99458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
99459   unsigned int jresult ;
99460   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99461   bool result;
99462
99463   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99464   {
99465     try {
99466       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99467     } catch (std::out_of_range& e) {
99468       {
99469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99470       };
99471     } catch (std::exception& e) {
99472       {
99473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99474       };
99475     } catch (Dali::DaliException e) {
99476       {
99477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99478       };
99479     } catch (...) {
99480       {
99481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99482       };
99483     }
99484   }
99485
99486   jresult = result;
99487   return jresult;
99488 }
99489
99490
99491 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
99492   unsigned long jresult ;
99493   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99494   std::size_t result;
99495
99496   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99497   {
99498     try {
99499       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99500     } catch (std::out_of_range& e) {
99501       {
99502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99503       };
99504     } catch (std::exception& e) {
99505       {
99506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99507       };
99508     } catch (Dali::DaliException e) {
99509       {
99510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99511       };
99512     } catch (...) {
99513       {
99514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99515       };
99516     }
99517   }
99518
99519   jresult = (unsigned long)result;
99520   return jresult;
99521 }
99522
99523
99524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
99525   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99526   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99527
99528   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99529   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99530   {
99531     try {
99532       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
99533     } catch (std::out_of_range& e) {
99534       {
99535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99536       };
99537     } catch (std::exception& e) {
99538       {
99539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99540       };
99541     } catch (Dali::DaliException e) {
99542       {
99543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99544       };
99545     } catch (...) {
99546       {
99547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99548       };
99549     }
99550   }
99551
99552 }
99553
99554
99555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
99556   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99557   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99558
99559   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99560   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99561   {
99562     try {
99563       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
99564     } catch (std::out_of_range& e) {
99565       {
99566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99567       };
99568     } catch (std::exception& e) {
99569       {
99570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99571       };
99572     } catch (Dali::DaliException e) {
99573       {
99574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99575       };
99576     } catch (...) {
99577       {
99578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99579       };
99580     }
99581   }
99582
99583 }
99584
99585
99586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
99587   unsigned int jresult ;
99588   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99589   Dali::Toolkit::Slider arg2 ;
99590   int arg3 ;
99591   Dali::Toolkit::Slider *argp2 ;
99592   bool result;
99593
99594   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99595   argp2 = (Dali::Toolkit::Slider *)jarg2;
99596   if (!argp2) {
99597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99598     return 0;
99599   }
99600   arg2 = *argp2;
99601   arg3 = (int)jarg3;
99602   {
99603     try {
99604       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
99605     } catch (std::out_of_range& e) {
99606       {
99607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99608       };
99609     } catch (std::exception& e) {
99610       {
99611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99612       };
99613     } catch (Dali::DaliException e) {
99614       {
99615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99616       };
99617     } catch (...) {
99618       {
99619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99620       };
99621     }
99622   }
99623
99624   jresult = result;
99625   return jresult;
99626 }
99627
99628
99629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99630   void * jresult ;
99631   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99632
99633   {
99634     try {
99635       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99636     } catch (std::out_of_range& e) {
99637       {
99638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99639       };
99640     } catch (std::exception& e) {
99641       {
99642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99643       };
99644     } catch (Dali::DaliException e) {
99645       {
99646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99647       };
99648     } catch (...) {
99649       {
99650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99651       };
99652     }
99653   }
99654
99655   jresult = (void *)result;
99656   return jresult;
99657 }
99658
99659
99660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99661   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99662
99663   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99664   {
99665     try {
99666       delete arg1;
99667     } catch (std::out_of_range& e) {
99668       {
99669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99670       };
99671     } catch (std::exception& e) {
99672       {
99673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99674       };
99675     } catch (Dali::DaliException e) {
99676       {
99677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99678       };
99679     } catch (...) {
99680       {
99681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99682       };
99683     }
99684   }
99685
99686 }
99687
99688
99689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99690   void * jresult ;
99691   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99692
99693   {
99694     try {
99695       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99696     } catch (std::out_of_range& e) {
99697       {
99698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99699       };
99700     } catch (std::exception& e) {
99701       {
99702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99703       };
99704     } catch (Dali::DaliException e) {
99705       {
99706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99707       };
99708     } catch (...) {
99709       {
99710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99711       };
99712     }
99713   }
99714
99715   jresult = (void *)result;
99716   return jresult;
99717 }
99718
99719
99720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99721   void * jresult ;
99722   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99723   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99724
99725   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99726   {
99727     try {
99728       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99729     } catch (std::out_of_range& e) {
99730       {
99731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99732       };
99733     } catch (std::exception& e) {
99734       {
99735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99736       };
99737     } catch (Dali::DaliException e) {
99738       {
99739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99740       };
99741     } catch (...) {
99742       {
99743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99744       };
99745     }
99746   }
99747
99748   jresult = (void *)result;
99749   return jresult;
99750 }
99751
99752
99753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99754   void * jresult ;
99755   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99756   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99757
99758   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99759   if (!arg1) {
99760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99761     return 0;
99762   }
99763   {
99764     try {
99765       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*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_delete_RulerPtr(void * jarg1) {
99791   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99792
99793   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99794   {
99795     try {
99796       delete arg1;
99797     } catch (std::out_of_range& e) {
99798       {
99799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99800       };
99801     } catch (std::exception& e) {
99802       {
99803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99804       };
99805     } catch (Dali::DaliException e) {
99806       {
99807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99808       };
99809     } catch (...) {
99810       {
99811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99812       };
99813     }
99814   }
99815
99816 }
99817
99818
99819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99820   void * jresult ;
99821   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99822   Dali::Toolkit::Ruler *result = 0 ;
99823
99824   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99825   {
99826     try {
99827       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99828     } catch (std::out_of_range& e) {
99829       {
99830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99831       };
99832     } catch (std::exception& e) {
99833       {
99834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99835       };
99836     } catch (Dali::DaliException e) {
99837       {
99838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99839       };
99840     } catch (...) {
99841       {
99842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99843       };
99844     }
99845   }
99846
99847   jresult = (void *)result;
99848   return jresult;
99849 }
99850
99851
99852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99853   void * jresult ;
99854   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99855   Dali::Toolkit::Ruler *result = 0 ;
99856
99857   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99858   {
99859     try {
99860       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99861     } catch (std::out_of_range& e) {
99862       {
99863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99864       };
99865     } catch (std::exception& e) {
99866       {
99867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99868       };
99869     } catch (Dali::DaliException e) {
99870       {
99871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99872       };
99873     } catch (...) {
99874       {
99875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99876       };
99877     }
99878   }
99879
99880   jresult = (void *)result;
99881   return jresult;
99882 }
99883
99884
99885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99886   void * jresult ;
99887   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99888   Dali::Toolkit::Ruler *result = 0 ;
99889
99890   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99891   {
99892     try {
99893       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99894     } catch (std::out_of_range& e) {
99895       {
99896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99897       };
99898     } catch (std::exception& e) {
99899       {
99900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99901       };
99902     } catch (Dali::DaliException e) {
99903       {
99904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99905       };
99906     } catch (...) {
99907       {
99908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99909       };
99910     }
99911   }
99912
99913   jresult = (void *)result;
99914   return jresult;
99915 }
99916
99917
99918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99919   void * jresult ;
99920   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99921   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99922   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99923
99924   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99925   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99926   if (!arg2) {
99927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99928     return 0;
99929   }
99930   {
99931     try {
99932       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99933     } catch (std::out_of_range& e) {
99934       {
99935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99936       };
99937     } catch (std::exception& e) {
99938       {
99939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99940       };
99941     } catch (Dali::DaliException e) {
99942       {
99943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99944       };
99945     } catch (...) {
99946       {
99947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99948       };
99949     }
99950   }
99951
99952   jresult = (void *)result;
99953   return jresult;
99954 }
99955
99956
99957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99958   void * jresult ;
99959   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99960   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99961   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99962
99963   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99964   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99965   {
99966     try {
99967       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99968     } catch (std::out_of_range& e) {
99969       {
99970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99971       };
99972     } catch (std::exception& e) {
99973       {
99974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99975       };
99976     } catch (Dali::DaliException e) {
99977       {
99978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99979       };
99980     } catch (...) {
99981       {
99982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99983       };
99984     }
99985   }
99986
99987   jresult = (void *)result;
99988   return jresult;
99989 }
99990
99991
99992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99993   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99994
99995   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99996   {
99997     try {
99998       (arg1)->Reset();
99999     } catch (std::out_of_range& e) {
100000       {
100001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100002       };
100003     } catch (std::exception& e) {
100004       {
100005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100006       };
100007     } catch (Dali::DaliException e) {
100008       {
100009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100010       };
100011     } catch (...) {
100012       {
100013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100014       };
100015     }
100016   }
100017
100018 }
100019
100020
100021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
100022   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100023   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
100024
100025   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100026   arg2 = (Dali::Toolkit::Ruler *)jarg2;
100027   {
100028     try {
100029       (arg1)->Reset(arg2);
100030     } catch (std::out_of_range& e) {
100031       {
100032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100033       };
100034     } catch (std::exception& e) {
100035       {
100036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100037       };
100038     } catch (Dali::DaliException e) {
100039       {
100040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100041       };
100042     } catch (...) {
100043       {
100044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100045       };
100046     }
100047   }
100048
100049 }
100050
100051
100052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
100053   void * jresult ;
100054   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100055   Dali::Toolkit::Ruler *result = 0 ;
100056
100057   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100058   {
100059     try {
100060       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
100061     } catch (std::out_of_range& e) {
100062       {
100063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100064       };
100065     } catch (std::exception& e) {
100066       {
100067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100068       };
100069     } catch (Dali::DaliException e) {
100070       {
100071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100072       };
100073     } catch (...) {
100074       {
100075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100076       };
100077     }
100078   }
100079
100080   jresult = (void *)result;
100081   return jresult;
100082 }
100083
100084
100085 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
100086   float jresult ;
100087   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100088   float arg2 ;
100089   float arg3 ;
100090   float result;
100091
100092   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100093   arg2 = (float)jarg2;
100094   arg3 = (float)jarg3;
100095   {
100096     try {
100097       result = (float)(*arg1)->Snap(arg2,arg3);
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 = result;
100118   return jresult;
100119 }
100120
100121
100122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
100123   float jresult ;
100124   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100125   float arg2 ;
100126   float result;
100127
100128   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100129   arg2 = (float)jarg2;
100130   {
100131     try {
100132       result = (float)(*arg1)->Snap(arg2);
100133     } catch (std::out_of_range& e) {
100134       {
100135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100136       };
100137     } catch (std::exception& e) {
100138       {
100139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100140       };
100141     } catch (Dali::DaliException e) {
100142       {
100143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100144       };
100145     } catch (...) {
100146       {
100147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100148       };
100149     }
100150   }
100151
100152   jresult = result;
100153   return jresult;
100154 }
100155
100156
100157 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
100158   float jresult ;
100159   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100160   unsigned int arg2 ;
100161   unsigned int *arg3 = 0 ;
100162   bool arg4 ;
100163   float result;
100164
100165   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100166   arg2 = (unsigned int)jarg2;
100167   arg3 = (unsigned int *)jarg3;
100168   arg4 = jarg4 ? true : false;
100169   {
100170     try {
100171       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
100172     } catch (std::out_of_range& e) {
100173       {
100174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100175       };
100176     } catch (std::exception& e) {
100177       {
100178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100179       };
100180     } catch (Dali::DaliException e) {
100181       {
100182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100183       };
100184     } catch (...) {
100185       {
100186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100187       };
100188     }
100189   }
100190
100191   jresult = result;
100192   return jresult;
100193 }
100194
100195
100196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
100197   unsigned int jresult ;
100198   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100199   float arg2 ;
100200   bool arg3 ;
100201   unsigned int result;
100202
100203   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100204   arg2 = (float)jarg2;
100205   arg3 = jarg3 ? true : false;
100206   {
100207     try {
100208       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
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_GetTotalPages(void * jarg1) {
100234   unsigned int jresult ;
100235   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100236   unsigned int result;
100237
100238   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100239   {
100240     try {
100241       result = (unsigned int)(*arg1)->GetTotalPages();
100242     } catch (std::out_of_range& e) {
100243       {
100244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100245       };
100246     } catch (std::exception& e) {
100247       {
100248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100249       };
100250     } catch (Dali::DaliException e) {
100251       {
100252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100253       };
100254     } catch (...) {
100255       {
100256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100257       };
100258     }
100259   }
100260
100261   jresult = result;
100262   return jresult;
100263 }
100264
100265
100266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
100267   int jresult ;
100268   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100269   Dali::Toolkit::Ruler::RulerType result;
100270
100271   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100272   {
100273     try {
100274       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
100275     } catch (std::out_of_range& e) {
100276       {
100277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100278       };
100279     } catch (std::exception& e) {
100280       {
100281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100282       };
100283     } catch (Dali::DaliException e) {
100284       {
100285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100286       };
100287     } catch (...) {
100288       {
100289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100290       };
100291     }
100292   }
100293
100294   jresult = (int)result;
100295   return jresult;
100296 }
100297
100298
100299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
100300   unsigned int jresult ;
100301   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100302   bool result;
100303
100304   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100305   {
100306     try {
100307       result = (bool)(*arg1)->IsEnabled();
100308     } catch (std::out_of_range& e) {
100309       {
100310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100311       };
100312     } catch (std::exception& e) {
100313       {
100314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100315       };
100316     } catch (Dali::DaliException e) {
100317       {
100318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100319       };
100320     } catch (...) {
100321       {
100322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100323       };
100324     }
100325   }
100326
100327   jresult = result;
100328   return jresult;
100329 }
100330
100331
100332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
100333   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100334
100335   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100336   {
100337     try {
100338       (*arg1)->Enable();
100339     } catch (std::out_of_range& e) {
100340       {
100341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100342       };
100343     } catch (std::exception& e) {
100344       {
100345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100346       };
100347     } catch (Dali::DaliException e) {
100348       {
100349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100350       };
100351     } catch (...) {
100352       {
100353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100354       };
100355     }
100356   }
100357
100358 }
100359
100360
100361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
100362   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100363
100364   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100365   {
100366     try {
100367       (*arg1)->Disable();
100368     } catch (std::out_of_range& e) {
100369       {
100370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100371       };
100372     } catch (std::exception& e) {
100373       {
100374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100375       };
100376     } catch (Dali::DaliException e) {
100377       {
100378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100379       };
100380     } catch (...) {
100381       {
100382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100383       };
100384     }
100385   }
100386
100387 }
100388
100389
100390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
100391   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100392   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
100393   Dali::Toolkit::RulerDomain *argp2 ;
100394
100395   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100396   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
100397   if (!argp2) {
100398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
100399     return ;
100400   }
100401   arg2 = *argp2;
100402   {
100403     try {
100404       (*arg1)->SetDomain(arg2);
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_GetDomain(void * jarg1) {
100428   void * jresult ;
100429   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100430   Dali::Toolkit::RulerDomain *result = 0 ;
100431
100432   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100433   {
100434     try {
100435       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
100436     } catch (std::out_of_range& e) {
100437       {
100438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100439       };
100440     } catch (std::exception& e) {
100441       {
100442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100443       };
100444     } catch (Dali::DaliException e) {
100445       {
100446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100447       };
100448     } catch (...) {
100449       {
100450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100451       };
100452     }
100453   }
100454
100455   jresult = (void *)result;
100456   return jresult;
100457 }
100458
100459
100460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
100461   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100462
100463   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100464   {
100465     try {
100466       (*arg1)->DisableDomain();
100467     } catch (std::out_of_range& e) {
100468       {
100469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100470       };
100471     } catch (std::exception& e) {
100472       {
100473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100474       };
100475     } catch (Dali::DaliException e) {
100476       {
100477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100478       };
100479     } catch (...) {
100480       {
100481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100482       };
100483     }
100484   }
100485
100486 }
100487
100488
100489 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
100490   float jresult ;
100491   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100492   float arg2 ;
100493   float arg3 ;
100494   float arg4 ;
100495   float result;
100496
100497   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100498   arg2 = (float)jarg2;
100499   arg3 = (float)jarg3;
100500   arg4 = (float)jarg4;
100501   {
100502     try {
100503       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
100504     } catch (std::out_of_range& e) {
100505       {
100506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100507       };
100508     } catch (std::exception& e) {
100509       {
100510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100511       };
100512     } catch (Dali::DaliException e) {
100513       {
100514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100515       };
100516     } catch (...) {
100517       {
100518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100519       };
100520     }
100521   }
100522
100523   jresult = result;
100524   return jresult;
100525 }
100526
100527
100528 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
100529   float jresult ;
100530   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100531   float arg2 ;
100532   float arg3 ;
100533   float result;
100534
100535   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100536   arg2 = (float)jarg2;
100537   arg3 = (float)jarg3;
100538   {
100539     try {
100540       result = (float)(*arg1)->Clamp(arg2,arg3);
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_2(void * jarg1, float jarg2) {
100566   float jresult ;
100567   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100568   float arg2 ;
100569   float result;
100570
100571   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100572   arg2 = (float)jarg2;
100573   {
100574     try {
100575       result = (float)(*arg1)->Clamp(arg2);
100576     } catch (std::out_of_range& e) {
100577       {
100578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100579       };
100580     } catch (std::exception& e) {
100581       {
100582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100583       };
100584     } catch (Dali::DaliException e) {
100585       {
100586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100587       };
100588     } catch (...) {
100589       {
100590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100591       };
100592     }
100593   }
100594
100595   jresult = result;
100596   return jresult;
100597 }
100598
100599
100600 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
100601   float jresult ;
100602   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100603   float arg2 ;
100604   float arg3 ;
100605   float arg4 ;
100606   Dali::Toolkit::ClampState *arg5 = 0 ;
100607   float result;
100608
100609   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100610   arg2 = (float)jarg2;
100611   arg3 = (float)jarg3;
100612   arg4 = (float)jarg4;
100613   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100614   if (!arg5) {
100615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100616     return 0;
100617   }
100618   {
100619     try {
100620       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100621     } catch (std::out_of_range& e) {
100622       {
100623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100624       };
100625     } catch (std::exception& e) {
100626       {
100627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100628       };
100629     } catch (Dali::DaliException e) {
100630       {
100631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100632       };
100633     } catch (...) {
100634       {
100635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100636       };
100637     }
100638   }
100639
100640   jresult = result;
100641   return jresult;
100642 }
100643
100644
100645 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100646   float jresult ;
100647   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100648   float arg2 ;
100649   float arg3 ;
100650   float arg4 ;
100651   float arg5 ;
100652   float result;
100653
100654   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100655   arg2 = (float)jarg2;
100656   arg3 = (float)jarg3;
100657   arg4 = (float)jarg4;
100658   arg5 = (float)jarg5;
100659   {
100660     try {
100661       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100662     } catch (std::out_of_range& e) {
100663       {
100664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100665       };
100666     } catch (std::exception& e) {
100667       {
100668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100669       };
100670     } catch (Dali::DaliException e) {
100671       {
100672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100673       };
100674     } catch (...) {
100675       {
100676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100677       };
100678     }
100679   }
100680
100681   jresult = result;
100682   return jresult;
100683 }
100684
100685
100686 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100687   float jresult ;
100688   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100689   float arg2 ;
100690   float arg3 ;
100691   float arg4 ;
100692   float result;
100693
100694   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100695   arg2 = (float)jarg2;
100696   arg3 = (float)jarg3;
100697   arg4 = (float)jarg4;
100698   {
100699     try {
100700       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100701     } catch (std::out_of_range& e) {
100702       {
100703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100704       };
100705     } catch (std::exception& e) {
100706       {
100707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100708       };
100709     } catch (Dali::DaliException e) {
100710       {
100711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100712       };
100713     } catch (...) {
100714       {
100715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100716       };
100717     }
100718   }
100719
100720   jresult = result;
100721   return jresult;
100722 }
100723
100724
100725 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100726   float jresult ;
100727   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100728   float arg2 ;
100729   float arg3 ;
100730   float result;
100731
100732   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100733   arg2 = (float)jarg2;
100734   arg3 = (float)jarg3;
100735   {
100736     try {
100737       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
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_3(void * jarg1, float jarg2) {
100763   float jresult ;
100764   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100765   float arg2 ;
100766   float result;
100767
100768   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100769   arg2 = (float)jarg2;
100770   {
100771     try {
100772       result = (float)(*arg1)->SnapAndClamp(arg2);
100773     } catch (std::out_of_range& e) {
100774       {
100775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100776       };
100777     } catch (std::exception& e) {
100778       {
100779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100780       };
100781     } catch (Dali::DaliException e) {
100782       {
100783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100784       };
100785     } catch (...) {
100786       {
100787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100788       };
100789     }
100790   }
100791
100792   jresult = result;
100793   return jresult;
100794 }
100795
100796
100797 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100798   float jresult ;
100799   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100800   float arg2 ;
100801   float arg3 ;
100802   float arg4 ;
100803   float arg5 ;
100804   Dali::Toolkit::ClampState *arg6 = 0 ;
100805   float result;
100806
100807   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100808   arg2 = (float)jarg2;
100809   arg3 = (float)jarg3;
100810   arg4 = (float)jarg4;
100811   arg5 = (float)jarg5;
100812   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100813   if (!arg6) {
100814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100815     return 0;
100816   }
100817   {
100818     try {
100819       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100820     } catch (std::out_of_range& e) {
100821       {
100822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100823       };
100824     } catch (std::exception& e) {
100825       {
100826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100827       };
100828     } catch (Dali::DaliException e) {
100829       {
100830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100831       };
100832     } catch (...) {
100833       {
100834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100835       };
100836     }
100837   }
100838
100839   jresult = result;
100840   return jresult;
100841 }
100842
100843
100844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100845   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100846
100847   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100848   {
100849     try {
100850       (*arg1)->Reference();
100851     } catch (std::out_of_range& e) {
100852       {
100853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100854       };
100855     } catch (std::exception& e) {
100856       {
100857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100858       };
100859     } catch (Dali::DaliException e) {
100860       {
100861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100862       };
100863     } catch (...) {
100864       {
100865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100866       };
100867     }
100868   }
100869
100870 }
100871
100872
100873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100874   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100875
100876   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100877   {
100878     try {
100879       (*arg1)->Unreference();
100880     } catch (std::out_of_range& e) {
100881       {
100882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100883       };
100884     } catch (std::exception& e) {
100885       {
100886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100887       };
100888     } catch (Dali::DaliException e) {
100889       {
100890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100891       };
100892     } catch (...) {
100893       {
100894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100895       };
100896     }
100897   }
100898
100899 }
100900
100901
100902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100903   int jresult ;
100904   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100905   int result;
100906
100907   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100908   {
100909     try {
100910       result = (int)(*arg1)->ReferenceCount();
100911     } catch (std::out_of_range& e) {
100912       {
100913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100914       };
100915     } catch (std::exception& e) {
100916       {
100917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100918       };
100919     } catch (Dali::DaliException e) {
100920       {
100921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100922       };
100923     } catch (...) {
100924       {
100925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100926       };
100927     }
100928   }
100929
100930   jresult = result;
100931   return jresult;
100932 }
100933
100934
100935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100936   unsigned int jresult ;
100937   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100938   bool result;
100939
100940   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100941   {
100942     try {
100943       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100944     } catch (std::out_of_range& e) {
100945       {
100946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100947       };
100948     } catch (std::exception& e) {
100949       {
100950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100951       };
100952     } catch (Dali::DaliException e) {
100953       {
100954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100955       };
100956     } catch (...) {
100957       {
100958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100959       };
100960     }
100961   }
100962
100963   jresult = result;
100964   return jresult;
100965 }
100966
100967
100968 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100969   unsigned long jresult ;
100970   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100971   std::size_t result;
100972
100973   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100974   {
100975     try {
100976       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100977     } catch (std::out_of_range& e) {
100978       {
100979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100980       };
100981     } catch (std::exception& e) {
100982       {
100983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100984       };
100985     } catch (Dali::DaliException e) {
100986       {
100987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100988       };
100989     } catch (...) {
100990       {
100991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100992       };
100993     }
100994   }
100995
100996   jresult = (unsigned long)result;
100997   return jresult;
100998 }
100999
101000
101001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
101002   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101003   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
101004
101005   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101006   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
101007   {
101008     try {
101009       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
101010     } catch (std::out_of_range& e) {
101011       {
101012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101013       };
101014     } catch (std::exception& e) {
101015       {
101016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101017       };
101018     } catch (Dali::DaliException e) {
101019       {
101020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101021       };
101022     } catch (...) {
101023       {
101024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101025       };
101026     }
101027   }
101028
101029 }
101030
101031
101032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
101033   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101034   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
101035
101036   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101037   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
101038   {
101039     try {
101040       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
101041     } catch (std::out_of_range& e) {
101042       {
101043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101044       };
101045     } catch (std::exception& e) {
101046       {
101047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101048       };
101049     } catch (Dali::DaliException e) {
101050       {
101051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101052       };
101053     } catch (...) {
101054       {
101055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101056       };
101057     }
101058   }
101059
101060 }
101061
101062
101063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
101064   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101065   Dali::Toolkit::Control arg2 ;
101066   Dali::Toolkit::Control *argp2 ;
101067
101068   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101069   argp2 = (Dali::Toolkit::Control *)jarg2;
101070   if (!argp2) {
101071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
101072     return ;
101073   }
101074   arg2 = *argp2;
101075   {
101076     try {
101077       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(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_new_ViewResourceReadySignal() {
101101   void * jresult ;
101102   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
101103
101104   {
101105     try {
101106       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
101107     } catch (std::out_of_range& e) {
101108       {
101109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101110       };
101111     } catch (std::exception& e) {
101112       {
101113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101114       };
101115     } catch (Dali::DaliException e) {
101116       {
101117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101118       };
101119     } catch (...) {
101120       {
101121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101122       };
101123     }
101124   }
101125
101126   jresult = (void *)result;
101127   return jresult;
101128 }
101129
101130
101131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
101132   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101133
101134   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101135   {
101136     try {
101137       delete arg1;
101138     } catch (std::out_of_range& e) {
101139       {
101140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101141       };
101142     } catch (std::exception& e) {
101143       {
101144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101145       };
101146     } catch (Dali::DaliException e) {
101147       {
101148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101149       };
101150     } catch (...) {
101151       {
101152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101153       };
101154     }
101155   }
101156
101157 }
101158
101159 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
101160   Dali::RefObject *result = NULL;
101161
101162   if (arg1)
101163   {
101164     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
101165   }
101166   return result;
101167 }
101168
101169 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
101170     return (Dali::RefObject *)jarg1;
101171 }
101172
101173 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
101174     return (Dali::SignalObserver *)jarg1;
101175 }
101176
101177 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
101178     return (Dali::ConnectionTrackerInterface *)jarg1;
101179 }
101180
101181 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
101182     return (Dali::BaseHandle *)jarg1;
101183 }
101184
101185 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
101186     return (Dali::BaseHandle *)jarg1;
101187 }
101188
101189 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
101190     return (Dali::BaseHandle *)jarg1;
101191 }
101192
101193 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
101194     return (Dali::BaseHandle *)jarg1;
101195 }
101196
101197 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
101198     return (Dali::BaseHandle *)jarg1;
101199 }
101200
101201 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
101202     return (Dali::BaseHandle *)jarg1;
101203 }
101204
101205 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
101206     return (Dali::BaseHandle *)jarg1;
101207 }
101208
101209 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
101210     return (Dali::BaseHandle *)jarg1;
101211 }
101212
101213 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
101214     return (Dali::BaseHandle *)jarg1;
101215 }
101216
101217 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
101218     return (Dali::BaseHandle *)jarg1;
101219 }
101220
101221 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
101222     return (Dali::BaseHandle *)jarg1;
101223 }
101224
101225 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
101226     return (Dali::BaseHandle *)jarg1;
101227 }
101228
101229 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
101230     return (Dali::BaseHandle *)jarg1;
101231 }
101232
101233 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
101234     return (Dali::Handle *)jarg1;
101235 }
101236
101237 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
101238     return (Dali::Handle *)jarg1;
101239 }
101240
101241 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
101242     return (Dali::BaseHandle *)jarg1;
101243 }
101244
101245 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
101246     return (Dali::BaseHandle *)jarg1;
101247 }
101248
101249 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
101250     return (Dali::Handle *)jarg1;
101251 }
101252
101253 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
101254     return (Dali::BaseHandle *)jarg1;
101255 }
101256
101257 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
101258     return (Dali::Handle *)jarg1;
101259 }
101260
101261 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
101262     return (Dali::GestureDetector *)jarg1;
101263 }
101264
101265 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
101266     return (Dali::Gesture *)jarg1;
101267 }
101268
101269 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
101270     return (Dali::Handle *)jarg1;
101271 }
101272
101273 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
101274     return (Dali::Actor *)jarg1;
101275 }
101276
101277 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
101278     return (Dali::BaseHandle *)jarg1;
101279 }
101280
101281 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
101282     return (Dali::RefObject *)jarg1;
101283 }
101284
101285 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
101286     return (Dali::Actor *)jarg1;
101287 }
101288
101289 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
101290     return (Dali::GestureDetector *)jarg1;
101291 }
101292
101293 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
101294     return (Dali::Gesture *)jarg1;
101295 }
101296
101297 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
101298     return (Dali::GestureDetector *)jarg1;
101299 }
101300
101301 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
101302     return (Dali::Gesture *)jarg1;
101303 }
101304
101305 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
101306     return (Dali::GestureDetector *)jarg1;
101307 }
101308
101309 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
101310     return (Dali::Gesture *)jarg1;
101311 }
101312
101313 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
101314     return (Dali::BaseHandle *)jarg1;
101315 }
101316
101317 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
101318     return (Dali::Handle *)jarg1;
101319 }
101320
101321 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
101322     return (Dali::Handle *)jarg1;
101323 }
101324
101325 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
101326     return (Dali::Handle *)jarg1;
101327 }
101328
101329 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
101330     return (Dali::Image *)jarg1;
101331 }
101332
101333 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
101334     return (Dali::Image *)jarg1;
101335 }
101336
101337 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
101338     return (Dali::Image *)jarg1;
101339 }
101340
101341 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
101342     return (Dali::RefObject *)jarg1;
101343 }
101344
101345 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
101346     return (Dali::Image *)jarg1;
101347 }
101348
101349 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
101350     return (Dali::Image *)jarg1;
101351 }
101352
101353 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
101354     return (Dali::ResourceImage *)jarg1;
101355 }
101356
101357 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
101358     return (Dali::Actor *)jarg1;
101359 }
101360
101361 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
101362     return (Dali::BaseHandle *)jarg1;
101363 }
101364
101365 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
101366     return (Dali::BaseHandle *)jarg1;
101367 }
101368
101369
101370 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
101371     return (Dali::BaseHandle *)jarg1;
101372 }
101373
101374 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
101375     return (Dali::BaseHandle *)jarg1;
101376 }
101377
101378 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
101379     return (Dali::CustomActorImpl *)jarg1;
101380 }
101381
101382 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
101383     return (Dali::CustomActor *)jarg1;
101384 }
101385
101386 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
101387     return (Dali::BaseHandle *)jarg1;
101388 }
101389
101390 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
101391     return (Dali::Toolkit::Control *)jarg1;
101392 }
101393
101394 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
101395     return (Dali::Toolkit::Control *)jarg1;
101396 }
101397
101398 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
101399     return (Dali::Toolkit::Button *)jarg1;
101400 }
101401
101402 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
101403     return (Dali::Toolkit::Button *)jarg1;
101404 }
101405
101406 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
101407     return (Dali::Toolkit::Button *)jarg1;
101408 }
101409
101410 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
101411     return (Dali::Toolkit::Control *)jarg1;
101412 }
101413
101414 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
101415     return (Dali::Toolkit::Control *)jarg1;
101416 }
101417
101418 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
101419     return (Dali::Toolkit::Control *)jarg1;
101420 }
101421
101422 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
101423     return (Dali::Toolkit::Control *)jarg1;
101424 }
101425
101426 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
101427     return (Dali::Toolkit::Control *)jarg1;
101428 }
101429
101430 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
101431     return (Dali::RefObject *)jarg1;
101432 }
101433
101434 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
101435     return (Dali::Toolkit::Scrollable *)jarg1;
101436 }
101437
101438 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
101439     return (Dali::BaseHandle *)jarg1;
101440 }
101441
101442 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
101443     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
101444 }
101445
101446 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
101447     return (Dali::RefObject *)jarg1;
101448 }
101449
101450 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
101451     return (Dali::Toolkit::Ruler *)jarg1;
101452 }
101453
101454 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
101455     return (Dali::Toolkit::Ruler *)jarg1;
101456 }
101457
101458 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
101459     return (Dali::Toolkit::Scrollable *)jarg1;
101460 }
101461
101462 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
101463     return (Dali::Toolkit::Control *)jarg1;
101464 }
101465
101466
101467 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
101468     return (Dali::Toolkit::Control *)jarg1;
101469 }
101470
101471 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
101472     return (Dali::BaseHandle *)jarg1;
101473 }
101474
101475 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
101476     return (Dali::BaseHandle *)jarg1;
101477 }
101478
101479 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
101480     return (Dali::Toolkit::Control *)jarg1;
101481 }
101482
101483 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
101484     return (Dali::Toolkit::Control *)jarg1;
101485 }
101486
101487 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
101488     return (Dali::Toolkit::Control *)jarg1;
101489 }
101490
101491 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
101492     return (Dali::Toolkit::Control *)jarg1;
101493 }
101494
101495 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
101496     return (Dali::Toolkit::Control *)jarg1;
101497 }
101498
101499 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
101500     return (Dali::Toolkit::Control *)jarg1;
101501 }
101502
101503 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
101504     return (Dali::Toolkit::PageTurnView *)jarg1;
101505 }
101506
101507 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
101508     return (Dali::Toolkit::PageTurnView *)jarg1;
101509 }
101510
101511 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
101512     return (Dali::Toolkit::Button *)jarg1;
101513 }
101514
101515 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
101516     return (Dali::BaseHandle *)jarg1;
101517 }
101518
101519 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
101520     return (Dali::BaseHandle *)jarg1;
101521 }
101522
101523 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
101524     return (Dali::BaseHandle *)jarg1;
101525 }
101526
101527 /*
101528  * Widget binding
101529  */
101530 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
101531     return (Dali::BaseHandle *)jarg1;
101532 }
101533
101534 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
101535     return (Dali::BaseObject *)jarg1;
101536 }
101537
101538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
101539   void * jresult ;
101540   Dali::Widget result;
101541
101542   {
101543     try {
101544       result = Dali::Widget::New();
101545     } catch (std::out_of_range& e) {
101546       {
101547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101548       };
101549     } catch (std::exception& e) {
101550       {
101551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101552       };
101553     } catch (...) {
101554       {
101555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101556       };
101557     }
101558   }
101559   jresult = new Dali::Widget((const Dali::Widget &)result);
101560   return jresult;
101561 }
101562
101563
101564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
101565   void * jresult ;
101566   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
101567   Dali::Widget result;
101568
101569   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101570
101571   if (!arg1) {
101572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
101573     return 0;
101574   }
101575   {
101576     try {
101577       jresult = new Dali::Widget(arg1);
101578     } catch (std::out_of_range& e) {
101579       {
101580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101581       };
101582     } catch (std::exception& e) {
101583       {
101584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101585       };
101586     } catch (...) {
101587       {
101588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101589       };
101590     }
101591   }
101592   return jresult;
101593 }
101594
101595
101596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
101597   void * jresult ;
101598   Dali::Widget *result = 0 ;
101599
101600   {
101601     try {
101602       result = (Dali::Widget *)new Dali::Widget();
101603     } catch (std::out_of_range& e) {
101604       {
101605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101606       };
101607     } catch (std::exception& e) {
101608       {
101609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101610       };
101611     } catch (...) {
101612       {
101613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101614       };
101615     }
101616   }
101617   jresult = (void *)result;
101618   return jresult;
101619 }
101620
101621
101622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
101623   void * jresult ;
101624   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101625   Dali::Widget *arg2 = 0 ;
101626   Dali::Widget *result = 0 ;
101627
101628   arg1 = (Dali::Widget *)jarg1;
101629   arg2 = (Dali::Widget *)jarg2;
101630   if (!arg2) {
101631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
101632     return 0;
101633   }
101634   {
101635     try {
101636       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
101637     } catch (std::out_of_range& e) {
101638       {
101639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101640       };
101641     } catch (std::exception& e) {
101642       {
101643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101644       };
101645     } catch (...) {
101646       {
101647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101648       };
101649     }
101650   }
101651   jresult = (void *)result;
101652   return jresult;
101653 }
101654
101655
101656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
101657   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101658
101659   arg1 = (Dali::Widget *)jarg1;
101660   {
101661     try {
101662       delete arg1;
101663     } catch (std::out_of_range& e) {
101664       {
101665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101666       };
101667     } catch (std::exception& e) {
101668       {
101669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101670       };
101671     } catch (...) {
101672       {
101673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101674       };
101675     }
101676   }
101677 }
101678
101679
101680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
101681   void * jresult ;
101682   SwigDirector_WidgetImpl* result;
101683   {
101684     try {
101685       result = new SwigDirector_WidgetImpl();
101686     } catch (std::out_of_range& e) {
101687       {
101688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101689       };
101690     } catch (std::exception& e) {
101691       {
101692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101693       };
101694     } catch (...) {
101695       {
101696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101697       };
101698     }
101699   }
101700   jresult = result;
101701   return jresult;
101702 }
101703
101704
101705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
101706   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101707   std::string *arg2 = 0 ;
101708   Dali::Window arg3 ;
101709   Dali::Window *argp3 ;
101710
101711   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101712   if (!jarg2) {
101713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101714     return ;
101715   }
101716   std::string arg2_str(jarg2);
101717   arg2 = &arg2_str;
101718   argp3 = (Dali::Window *)jarg3;
101719   if (!argp3) {
101720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101721     return ;
101722   }
101723   arg3 = *argp3;
101724   {
101725     try {
101726       (arg1)->OnCreate((std::string const &)*arg2,arg3);
101727     } catch (std::out_of_range& e) {
101728       {
101729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101730       };
101731     } catch (std::exception& e) {
101732       {
101733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101734       };
101735     } catch (...) {
101736       {
101737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101738       };
101739     }
101740   }
101741 }
101742
101743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
101744   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101745   std::string *arg2 = 0 ;
101746   Dali::Window arg3 ;
101747   Dali::Window *argp3 ;
101748
101749   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101750   if (!jarg2) {
101751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101752     return ;
101753   }
101754   std::string arg2_str(jarg2);
101755   arg2 = &arg2_str;
101756   argp3 = (Dali::Window *)jarg3;
101757   if (!argp3) {
101758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101759     return ;
101760   }
101761   arg3 = *argp3;
101762   {
101763     try {
101764       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
101765     } catch (std::out_of_range& e) {
101766       {
101767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101768       };
101769     } catch (std::exception& e) {
101770       {
101771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101772       };
101773     } catch (...) {
101774       {
101775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101776       };
101777     }
101778   }
101779 }
101780
101781
101782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
101783   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101784   std::string *arg2 = 0 ;
101785   Dali::Widget::Termination arg3 ;
101786
101787   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101788   if (!jarg2) {
101789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101790     return ;
101791   }
101792   std::string arg2_str(jarg2);
101793   arg2 = &arg2_str;
101794   arg3 = (Dali::Widget::Termination)jarg3;
101795   {
101796     try {
101797       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
101798     } catch (std::out_of_range& e) {
101799       {
101800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101801       };
101802     } catch (std::exception& e) {
101803       {
101804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101805       };
101806     } catch (...) {
101807       {
101808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101809       };
101810     }
101811   }
101812 }
101813
101814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101815   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101816   std::string *arg2 = 0 ;
101817   Dali::Widget::Termination arg3 ;
101818
101819   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101820   if (!jarg2) {
101821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101822     return ;
101823   }
101824   std::string arg2_str(jarg2);
101825   arg2 = &arg2_str;
101826   arg3 = (Dali::Widget::Termination)jarg3;
101827   {
101828     try {
101829       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
101830     } catch (std::out_of_range& e) {
101831       {
101832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101833       };
101834     } catch (std::exception& e) {
101835       {
101836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101837       };
101838     } catch (...) {
101839       {
101840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101841       };
101842     }
101843   }
101844 }
101845
101846
101847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
101848   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101849
101850   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101851   {
101852     try {
101853       (arg1)->OnPause();
101854     } catch (std::out_of_range& e) {
101855       {
101856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101857       };
101858     } catch (std::exception& e) {
101859       {
101860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101861       };
101862     } catch (...) {
101863       {
101864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101865       };
101866     }
101867   }
101868 }
101869
101870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
101871   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101872
101873   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101874   {
101875     try {
101876       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
101877     } catch (std::out_of_range& e) {
101878       {
101879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101880       };
101881     } catch (std::exception& e) {
101882       {
101883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101884       };
101885     } catch (...) {
101886       {
101887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101888       };
101889     }
101890   }
101891 }
101892
101893
101894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101895   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101896
101897   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101898   {
101899     try {
101900       (arg1)->OnResume();
101901     } catch (std::out_of_range& e) {
101902       {
101903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101904       };
101905     } catch (std::exception& e) {
101906       {
101907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101908       };
101909     } catch (...) {
101910       {
101911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101912       };
101913     }
101914   }
101915 }
101916
101917
101918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101919   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101920
101921   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101922   {
101923     try {
101924       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101925     } catch (std::out_of_range& e) {
101926       {
101927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101928       };
101929     } catch (std::exception& e) {
101930       {
101931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101932       };
101933     } catch (...) {
101934       {
101935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101936       };
101937     }
101938   }
101939 }
101940
101941
101942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101943   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101944   Dali::Window arg2 ;
101945   Dali::Window *argp2 ;
101946
101947   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101948   argp2 = (Dali::Window *)jarg2;
101949   if (!argp2) {
101950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101951     return ;
101952   }
101953   arg2 = *argp2;
101954   {
101955     try {
101956       (arg1)->OnResize(arg2);
101957     } catch (std::out_of_range& e) {
101958       {
101959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101960       };
101961     } catch (std::exception& e) {
101962       {
101963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101964       };
101965     } catch (...) {
101966       {
101967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101968       };
101969     }
101970   }
101971 }
101972
101973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
101974   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101975   Dali::Window arg2 ;
101976   Dali::Window *argp2 ;
101977
101978   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101979   argp2 = (Dali::Window *)jarg2;
101980   if (!argp2) {
101981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101982     return ;
101983   }
101984   arg2 = *argp2;
101985   {
101986     try {
101987       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
101988     } catch (std::out_of_range& e) {
101989       {
101990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101991       };
101992     } catch (std::exception& e) {
101993       {
101994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101995       };
101996     } catch (...) {
101997       {
101998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101999       };
102000     }
102001   }
102002 }
102003
102004
102005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
102006   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102007   std::string *arg2 = 0 ;
102008   int arg3 ;
102009
102010   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102011   if (!jarg2) {
102012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102013     return ;
102014   }
102015   std::string arg2_str(jarg2);
102016   arg2 = &arg2_str;
102017   arg3 = (int)jarg3;
102018   {
102019     try {
102020       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
102021     } catch (std::out_of_range& e) {
102022       {
102023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102024       };
102025     } catch (std::exception& e) {
102026       {
102027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102028       };
102029     } catch (...) {
102030       {
102031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102032       };
102033     }
102034   }
102035 }
102036
102037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
102038   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102039   std::string *arg2 = 0 ;
102040   int arg3 ;
102041
102042   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102043   if (!jarg2) {
102044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102045     return ;
102046   }
102047   std::string arg2_str(jarg2);
102048   arg2 = &arg2_str;
102049   arg3 = (int)jarg3;
102050   {
102051     try {
102052       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
102053     } catch (std::out_of_range& e) {
102054       {
102055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102056       };
102057     } catch (std::exception& e) {
102058       {
102059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102060       };
102061     } catch (...) {
102062       {
102063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102064       };
102065     }
102066   }
102067 }
102068
102069
102070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
102071   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102072   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102073   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102074
102075   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102076   arg2 = (Dali::SlotObserver *)jarg2;
102077   arg3 = (Dali::CallbackBase *)jarg3;
102078   {
102079     try {
102080       (arg1)->SignalConnected(arg2,arg3);
102081     } catch (std::out_of_range& e) {
102082       {
102083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102084       };
102085     } catch (std::exception& e) {
102086       {
102087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102088       };
102089     } catch (...) {
102090       {
102091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102092       };
102093     }
102094   }
102095 }
102096
102097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
102098   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102099   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102100   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102101
102102   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102103   arg2 = (Dali::SlotObserver *)jarg2;
102104   arg3 = (Dali::CallbackBase *)jarg3;
102105   {
102106     try {
102107       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
102108     } catch (std::out_of_range& e) {
102109       {
102110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102111       };
102112     } catch (std::exception& e) {
102113       {
102114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102115       };
102116     } catch (...) {
102117       {
102118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102119       };
102120     }
102121   }
102122 }
102123
102124
102125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
102126   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102127   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102128   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102129
102130   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102131   arg2 = (Dali::SlotObserver *)jarg2;
102132   arg3 = (Dali::CallbackBase *)jarg3;
102133   {
102134     try {
102135       (arg1)->SignalDisconnected(arg2,arg3);
102136     } catch (std::out_of_range& e) {
102137       {
102138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102139       };
102140     } catch (std::exception& e) {
102141       {
102142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102143       };
102144     } catch (...) {
102145       {
102146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102147       };
102148     }
102149   }
102150 }
102151
102152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
102153   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102154   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102155   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102156
102157   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102158   arg2 = (Dali::SlotObserver *)jarg2;
102159   arg3 = (Dali::CallbackBase *)jarg3;
102160   {
102161     try {
102162       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
102163     } catch (std::out_of_range& e) {
102164       {
102165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102166       };
102167     } catch (std::exception& e) {
102168       {
102169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102170       };
102171     } catch (...) {
102172       {
102173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102174       };
102175     }
102176   }
102177 }
102178
102179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
102180   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102181   std::string *arg2 = 0 ;
102182
102183   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102184   if (!jarg2) {
102185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102186     return ;
102187   }
102188   std::string arg2_str(jarg2);
102189   arg2 = &arg2_str;
102190   {
102191     try {
102192       (arg1)->SetContentInfo((std::string const &)*arg2);
102193     } catch (std::out_of_range& e) {
102194       {
102195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102196       };
102197     } catch (std::exception& e) {
102198       {
102199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102200       };
102201     } catch (...) {
102202       {
102203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102204       };
102205     }
102206   }
102207 }
102208
102209
102210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
102211   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102212   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
102213
102214   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102215   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
102216   {
102217     try {
102218       (arg1)->SetImpl(arg2);
102219     } catch (std::out_of_range& e) {
102220       {
102221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102222       };
102223     } catch (std::exception& e) {
102224       {
102225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102226       };
102227     } catch (...) {
102228       {
102229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102230       };
102231     }
102232   }
102233 }
102234
102235 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) {
102236
102237   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
102238   if (director) {
102239     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
102240   }
102241 }
102242
102243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
102244   void * jresult ;
102245   Dali::Widget *arg1 = 0 ;
102246   SwigDirector_WidgetImpl *result = 0 ;
102247
102248   arg1 = (Dali::Widget *)jarg1;
102249   if (!arg1) {
102250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
102251     return 0;
102252   }
102253   {
102254     try {
102255       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
102256     } catch (std::out_of_range& e) {
102257       {
102258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102259       };
102260     } catch (std::exception& e) {
102261       {
102262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102263       };
102264     } catch (...) {
102265       {
102266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102267       };
102268     }
102269   }
102270
102271   jresult = (void *)result;
102272   return jresult;
102273 }
102274
102275
102276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
102277   void * jresult ;
102278   int *arg1 = (int *) 0 ;
102279   char ***arg2 ;
102280   std::string *arg3 = 0 ;
102281   Dali::WidgetApplication result;
102282   {
102283     int index = 0;
102284     int length = 0;
102285     char *retPtr;
102286     char *nextPtr;
102287     argWidgetC = jarg1;
102288     argWidgetV = new char*[jarg1 + 1];
102289
102290     retPtr = strtok_r( jarg2, " ", &nextPtr);
102291     if( retPtr )
102292     {
102293       length = strlen(retPtr);
102294     }
102295     argWidgetV[index] = new char[length + 1];
102296     if( retPtr )
102297     {
102298       strncpy(argWidgetV[index], retPtr, length);
102299     }
102300     argWidgetV[index][length] = '\0';
102301     index++;
102302
102303     while (index < jarg1)
102304     {
102305       length = 0;
102306       retPtr = strtok_r(NULL, " ", &nextPtr);
102307       if( retPtr )
102308       {
102309         length = strlen(retPtr);
102310       }
102311       argWidgetV[index] = new char[length + 1];
102312       if( retPtr )
102313       {
102314         strncpy(argWidgetV[index], retPtr, length);
102315       }
102316       argWidgetV[index][length] = '\0';
102317       index++;
102318     }
102319
102320     argWidgetV[jarg1] = NULL;
102321     argWidgetC = jarg1;
102322
102323     arg1 = &argWidgetC;
102324     arg2 = &argWidgetV;
102325   }
102326
102327   if (!jarg3) {
102328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102329     return 0;
102330   }
102331   std::string arg3_str(jarg3);
102332   arg3 = &arg3_str;
102333   {
102334     try {
102335       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
102336     } catch (std::out_of_range& e) {
102337       {
102338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102339       };
102340     } catch (std::exception& e) {
102341       {
102342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102343       };
102344     } catch (...) {
102345       {
102346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102347       };
102348     }
102349   }
102350   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
102351
102352   return jresult;
102353 }
102354
102355
102356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
102357   void * jresult ;
102358   Dali::WidgetApplication *result = 0 ;
102359
102360   {
102361     try {
102362       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
102363     } catch (std::out_of_range& e) {
102364       {
102365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102366       };
102367     } catch (std::exception& e) {
102368       {
102369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102370       };
102371     } catch (...) {
102372       {
102373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102374       };
102375     }
102376   }
102377   jresult = (void *)result;
102378   return jresult;
102379 }
102380
102381
102382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
102383   void * jresult ;
102384   Dali::WidgetApplication *arg1 = 0 ;
102385   Dali::WidgetApplication *result = 0 ;
102386
102387   arg1 = (Dali::WidgetApplication *)jarg1;
102388   if (!arg1) {
102389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102390     return 0;
102391   }
102392   {
102393     try {
102394       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
102395     } catch (std::out_of_range& e) {
102396       {
102397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102398       };
102399     } catch (std::exception& e) {
102400       {
102401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102402       };
102403     } catch (...) {
102404       {
102405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102406       };
102407     }
102408   }
102409   jresult = (void *)result;
102410   return jresult;
102411 }
102412
102413
102414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
102415   void * jresult ;
102416   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102417   Dali::WidgetApplication *arg2 = 0 ;
102418   Dali::WidgetApplication *result = 0 ;
102419
102420   arg1 = (Dali::WidgetApplication *)jarg1;
102421   arg2 = (Dali::WidgetApplication *)jarg2;
102422   if (!arg2) {
102423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102424     return 0;
102425   }
102426   {
102427     try {
102428       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
102429     } catch (std::out_of_range& e) {
102430       {
102431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102432       };
102433     } catch (std::exception& e) {
102434       {
102435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102436       };
102437     } catch (...) {
102438       {
102439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102440       };
102441     }
102442   }
102443   jresult = (void *)result;
102444   return jresult;
102445 }
102446
102447
102448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
102449   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102450
102451   arg1 = (Dali::WidgetApplication *)jarg1;
102452   {
102453     try {
102454       delete arg1;
102455       if( argWidgetV )
102456       {
102457         // free string data
102458         for( int i=0; i < argWidgetC+1; i++)
102459         {
102460           delete [] argWidgetV[i];
102461         }
102462         delete [] argWidgetV;
102463       }
102464     } catch (std::out_of_range& e) {
102465       {
102466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102467       };
102468     } catch (std::exception& e) {
102469       {
102470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102471       };
102472     } catch (...) {
102473       {
102474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102475       };
102476     }
102477   }
102478 }
102479
102480
102481 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
102482 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
102483
102484 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
102485 {
102486   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
102487   return *widget;
102488 }
102489
102490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
102491   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102492   std::string *arg2 = 0 ;
102493
102494   arg1 = (Dali::WidgetApplication *)jarg1;
102495   if (!jarg2) {
102496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102497     return ;
102498   }
102499   std::string arg2_str(*jarg2);
102500   arg2 = &arg2_str;
102501
102502   if(!_CSharpCreateWidgetFunction)
102503   {
102504     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
102505   }
102506
102507   {
102508     try {
102509       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
102510     } catch (std::out_of_range& e) {
102511       {
102512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102513       };
102514     } catch (std::exception& e) {
102515       {
102516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102517       };
102518     } catch (...) {
102519       {
102520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102521       };
102522     }
102523   }
102524
102525   //Typemap argout in c++ file.
102526   //This will convert c++ string to c# string
102527   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
102528 }
102529
102530
102531 //for PixelBuffer and ImageLoading
102532
102533 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
102534     return (Dali::BaseHandle *)jarg1;
102535 }
102536
102537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
102538   void * jresult ;
102539   unsigned int arg1 ;
102540   unsigned int arg2 ;
102541   Dali::Pixel::Format arg3 ;
102542   Dali::Devel::PixelBuffer result;
102543
102544   arg1 = (unsigned int)jarg1;
102545   arg2 = (unsigned int)jarg2;
102546   arg3 = (Dali::Pixel::Format)jarg3;
102547   {
102548     try {
102549       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
102550     } catch (std::out_of_range& e) {
102551       {
102552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102553       };
102554     } catch (std::exception& e) {
102555       {
102556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102557       };
102558     } catch (...) {
102559       {
102560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102561       };
102562     }
102563   }
102564   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102565   return jresult;
102566 }
102567
102568
102569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
102570   void * jresult ;
102571   Dali::Devel::PixelBuffer *result = 0 ;
102572
102573   {
102574     try {
102575       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
102576     } catch (std::out_of_range& e) {
102577       {
102578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102579       };
102580     } catch (std::exception& e) {
102581       {
102582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102583       };
102584     } catch (...) {
102585       {
102586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102587       };
102588     }
102589   }
102590   jresult = (void *)result;
102591   return jresult;
102592 }
102593
102594
102595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
102596   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102597
102598   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102599   {
102600     try {
102601       delete arg1;
102602     } catch (std::out_of_range& e) {
102603       {
102604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102605       };
102606     } catch (std::exception& e) {
102607       {
102608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102609       };
102610     } catch (...) {
102611       {
102612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102613       };
102614     }
102615   }
102616 }
102617
102618
102619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
102620   void * jresult ;
102621   Dali::Devel::PixelBuffer *arg1 = 0 ;
102622   Dali::Devel::PixelBuffer *result = 0 ;
102623
102624   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102625   if (!arg1) {
102626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102627     return 0;
102628   }
102629   {
102630     try {
102631       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
102632     } catch (std::out_of_range& e) {
102633       {
102634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102635       };
102636     } catch (std::exception& e) {
102637       {
102638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102639       };
102640     } catch (...) {
102641       {
102642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102643       };
102644     }
102645   }
102646   jresult = (void *)result;
102647   return jresult;
102648 }
102649
102650
102651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
102652   void * jresult ;
102653   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102654   Dali::Devel::PixelBuffer *arg2 = 0 ;
102655   Dali::Devel::PixelBuffer *result = 0 ;
102656
102657   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102658   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
102659   if (!arg2) {
102660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102661     return 0;
102662   }
102663   {
102664     try {
102665       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
102666     } catch (std::out_of_range& e) {
102667       {
102668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102669       };
102670     } catch (std::exception& e) {
102671       {
102672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102673       };
102674     } catch (...) {
102675       {
102676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102677       };
102678     }
102679   }
102680   jresult = (void *)result;
102681   return jresult;
102682 }
102683
102684
102685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
102686   void * jresult ;
102687   Dali::Devel::PixelBuffer *arg1 = 0 ;
102688   Dali::PixelData result;
102689
102690   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102691   if (!arg1) {
102692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
102693     return 0;
102694   }
102695   {
102696     try {
102697       result = Dali::Devel::PixelBuffer::Convert(*arg1);
102698     } catch (std::out_of_range& e) {
102699       {
102700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102701       };
102702     } catch (std::exception& e) {
102703       {
102704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102705       };
102706     } catch (...) {
102707       {
102708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102709       };
102710     }
102711   }
102712   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102713   return jresult;
102714 }
102715
102716
102717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
102718   void * jresult ;
102719   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102720   Dali::PixelData result;
102721
102722   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102723   {
102724     try {
102725       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
102726     } catch (std::out_of_range& e) {
102727       {
102728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102729       };
102730     } catch (std::exception& e) {
102731       {
102732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102733       };
102734     } catch (...) {
102735       {
102736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102737       };
102738     }
102739   }
102740   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102741   return jresult;
102742 }
102743
102744
102745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
102746   void * jresult ;
102747   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102748   unsigned char *result = 0 ;
102749
102750   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102751   {
102752     try {
102753       result = (unsigned char *)(arg1)->GetBuffer();
102754     } catch (std::out_of_range& e) {
102755       {
102756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102757       };
102758     } catch (std::exception& e) {
102759       {
102760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102761       };
102762     } catch (...) {
102763       {
102764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102765       };
102766     }
102767   }
102768   jresult = (void *)result;
102769   return jresult;
102770 }
102771
102772
102773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
102774   unsigned int jresult ;
102775   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102776   unsigned int result;
102777
102778   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102779   {
102780     try {
102781       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
102782     } catch (std::out_of_range& e) {
102783       {
102784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102785       };
102786     } catch (std::exception& e) {
102787       {
102788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102789       };
102790     } catch (...) {
102791       {
102792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102793       };
102794     }
102795   }
102796   jresult = result;
102797   return jresult;
102798 }
102799
102800
102801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
102802   unsigned int jresult ;
102803   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102804   unsigned int result;
102805
102806   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102807   {
102808     try {
102809       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
102810     } catch (std::out_of_range& e) {
102811       {
102812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102813       };
102814     } catch (std::exception& e) {
102815       {
102816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102817       };
102818     } catch (...) {
102819       {
102820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102821       };
102822     }
102823   }
102824   jresult = result;
102825   return jresult;
102826 }
102827
102828
102829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
102830   int jresult ;
102831   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102832   Dali::Pixel::Format result;
102833
102834   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102835   {
102836     try {
102837       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
102838     } catch (std::out_of_range& e) {
102839       {
102840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102841       };
102842     } catch (std::exception& e) {
102843       {
102844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102845       };
102846     } catch (...) {
102847       {
102848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102849       };
102850     }
102851   }
102852   jresult = (int)result;
102853   return jresult;
102854 }
102855
102856
102857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
102858   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102859   Dali::Devel::PixelBuffer arg2 ;
102860   float arg3 ;
102861   bool arg4 ;
102862   Dali::Devel::PixelBuffer *argp2 ;
102863
102864   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102865   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102866   if (!argp2) {
102867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102868     return ;
102869   }
102870   arg2 = *argp2;
102871   arg3 = (float)jarg3;
102872   arg4 = jarg4 ? true : false;
102873   {
102874     try {
102875       (arg1)->ApplyMask(arg2,arg3,arg4);
102876     } catch (std::out_of_range& e) {
102877       {
102878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102879       };
102880     } catch (std::exception& e) {
102881       {
102882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102883       };
102884     } catch (...) {
102885       {
102886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102887       };
102888     }
102889   }
102890 }
102891
102892
102893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102894   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102895   Dali::Devel::PixelBuffer arg2 ;
102896   float arg3 ;
102897   Dali::Devel::PixelBuffer *argp2 ;
102898
102899   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102900   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102901   if (!argp2) {
102902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102903     return ;
102904   }
102905   arg2 = *argp2;
102906   arg3 = (float)jarg3;
102907   {
102908     try {
102909       (arg1)->ApplyMask(arg2,arg3);
102910     } catch (std::out_of_range& e) {
102911       {
102912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102913       };
102914     } catch (std::exception& e) {
102915       {
102916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102917       };
102918     } catch (...) {
102919       {
102920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102921       };
102922     }
102923   }
102924 }
102925
102926
102927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102928   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102929   Dali::Devel::PixelBuffer arg2 ;
102930   Dali::Devel::PixelBuffer *argp2 ;
102931
102932   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102933   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102934   if (!argp2) {
102935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102936     return ;
102937   }
102938   arg2 = *argp2;
102939   {
102940     try {
102941       (arg1)->ApplyMask(arg2);
102942     } catch (std::out_of_range& e) {
102943       {
102944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102945       };
102946     } catch (std::exception& e) {
102947       {
102948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102949       };
102950     } catch (...) {
102951       {
102952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102953       };
102954     }
102955   }
102956 }
102957
102958
102959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
102960   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102961   float arg2 ;
102962
102963   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102964   arg2 = (float)jarg2;
102965   {
102966     try {
102967       (arg1)->ApplyGaussianBlur(arg2);
102968     } catch (std::out_of_range& e) {
102969       {
102970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102971       };
102972     } catch (std::exception& e) {
102973       {
102974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102975       };
102976     } catch (...) {
102977       {
102978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102979       };
102980     }
102981   }
102982 }
102983
102984
102985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
102986   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102987   uint16_t arg2 ;
102988   uint16_t arg3 ;
102989   uint16_t arg4 ;
102990   uint16_t arg5 ;
102991
102992   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102993   arg2 = (uint16_t)jarg2;
102994   arg3 = (uint16_t)jarg3;
102995   arg4 = (uint16_t)jarg4;
102996   arg5 = (uint16_t)jarg5;
102997   {
102998     try {
102999       (arg1)->Crop(arg2,arg3,arg4,arg5);
103000     } catch (std::out_of_range& e) {
103001       {
103002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103003       };
103004     } catch (std::exception& e) {
103005       {
103006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103007       };
103008     } catch (...) {
103009       {
103010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103011       };
103012     }
103013   }
103014 }
103015
103016
103017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
103018   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
103019   uint16_t arg2 ;
103020   uint16_t arg3 ;
103021
103022   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
103023   arg2 = (uint16_t)jarg2;
103024   arg3 = (uint16_t)jarg3;
103025   {
103026     try {
103027       (arg1)->Resize(arg2,arg3);
103028     } catch (std::out_of_range& e) {
103029       {
103030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103031       };
103032     } catch (std::exception& e) {
103033       {
103034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103035       };
103036     } catch (...) {
103037       {
103038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103039       };
103040     }
103041   }
103042 }
103043
103044
103045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_2(void * jarg1) {
103046   void * jresult ;
103047   Dali::Internal::Adaptor::PixelBuffer *arg1 = (Dali::Internal::Adaptor::PixelBuffer *) 0 ;
103048   Dali::Devel::PixelBuffer *result = 0 ;
103049
103050   arg1 = (Dali::Internal::Adaptor::PixelBuffer *)jarg1;
103051   {
103052     try {
103053       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer(arg1);
103054     } catch (std::out_of_range& e) {
103055       {
103056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103057       };
103058     } catch (std::exception& e) {
103059       {
103060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103061       };
103062     } catch (...) {
103063       {
103064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103065       };
103066     }
103067   }
103068   jresult = (void *)result;
103069   return jresult;
103070 }
103071
103072
103073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103074   void * jresult ;
103075   std::string *arg1 = 0 ;
103076   Dali::ImageDimensions arg2 ;
103077   Dali::FittingMode::Type arg3 ;
103078   Dali::SamplingMode::Type arg4 ;
103079   bool arg5 ;
103080   Dali::ImageDimensions *argp2 ;
103081   Dali::Devel::PixelBuffer result;
103082
103083   if (!jarg1) {
103084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103085     return 0;
103086   }
103087   std::string arg1_str(jarg1);
103088   arg1 = &arg1_str;
103089   argp2 = (Dali::ImageDimensions *)jarg2;
103090   if (!argp2) {
103091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103092     return 0;
103093   }
103094   arg2 = *argp2;
103095   arg3 = (Dali::FittingMode::Type)jarg3;
103096   arg4 = (Dali::SamplingMode::Type)jarg4;
103097   arg5 = jarg5 ? true : false;
103098   {
103099     try {
103100       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103101     } catch (std::out_of_range& e) {
103102       {
103103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103104       };
103105     } catch (std::exception& e) {
103106       {
103107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103108       };
103109     } catch (...) {
103110       {
103111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103112       };
103113     }
103114   }
103115   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103116
103117   return jresult;
103118 }
103119
103120
103121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103122   void * jresult ;
103123   std::string *arg1 = 0 ;
103124   Dali::ImageDimensions arg2 ;
103125   Dali::FittingMode::Type arg3 ;
103126   Dali::SamplingMode::Type arg4 ;
103127   Dali::ImageDimensions *argp2 ;
103128   Dali::Devel::PixelBuffer result;
103129
103130   if (!jarg1) {
103131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103132     return 0;
103133   }
103134   std::string arg1_str(jarg1);
103135   arg1 = &arg1_str;
103136   argp2 = (Dali::ImageDimensions *)jarg2;
103137   if (!argp2) {
103138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103139     return 0;
103140   }
103141   arg2 = *argp2;
103142   arg3 = (Dali::FittingMode::Type)jarg3;
103143   arg4 = (Dali::SamplingMode::Type)jarg4;
103144   {
103145     try {
103146       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
103147     } catch (std::out_of_range& e) {
103148       {
103149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103150       };
103151     } catch (std::exception& e) {
103152       {
103153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103154       };
103155     } catch (...) {
103156       {
103157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103158       };
103159     }
103160   }
103161   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103162
103163   return jresult;
103164 }
103165
103166
103167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103168   void * jresult ;
103169   std::string *arg1 = 0 ;
103170   Dali::ImageDimensions arg2 ;
103171   Dali::FittingMode::Type arg3 ;
103172   Dali::ImageDimensions *argp2 ;
103173   Dali::Devel::PixelBuffer result;
103174
103175   if (!jarg1) {
103176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103177     return 0;
103178   }
103179   std::string arg1_str(jarg1);
103180   arg1 = &arg1_str;
103181   argp2 = (Dali::ImageDimensions *)jarg2;
103182   if (!argp2) {
103183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103184     return 0;
103185   }
103186   arg2 = *argp2;
103187   arg3 = (Dali::FittingMode::Type)jarg3;
103188   {
103189     try {
103190       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
103191     } catch (std::out_of_range& e) {
103192       {
103193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103194       };
103195     } catch (std::exception& e) {
103196       {
103197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103198       };
103199     } catch (...) {
103200       {
103201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103202       };
103203     }
103204   }
103205   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103206
103207   return jresult;
103208 }
103209
103210
103211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
103212   void * jresult ;
103213   std::string *arg1 = 0 ;
103214   Dali::ImageDimensions arg2 ;
103215   Dali::ImageDimensions *argp2 ;
103216   Dali::Devel::PixelBuffer result;
103217
103218   if (!jarg1) {
103219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103220     return 0;
103221   }
103222   std::string arg1_str(jarg1);
103223   arg1 = &arg1_str;
103224   argp2 = (Dali::ImageDimensions *)jarg2;
103225   if (!argp2) {
103226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103227     return 0;
103228   }
103229   arg2 = *argp2;
103230   {
103231     try {
103232       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
103233     } catch (std::out_of_range& e) {
103234       {
103235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103236       };
103237     } catch (std::exception& e) {
103238       {
103239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103240       };
103241     } catch (...) {
103242       {
103243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103244       };
103245     }
103246   }
103247   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103248
103249   return jresult;
103250 }
103251
103252
103253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
103254   void * jresult ;
103255   std::string *arg1 = 0 ;
103256   Dali::Devel::PixelBuffer result;
103257
103258   if (!jarg1) {
103259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103260     return 0;
103261   }
103262   std::string arg1_str(jarg1);
103263   arg1 = &arg1_str;
103264   {
103265     try {
103266       result = Dali::LoadImageFromFile((std::string const &)*arg1);
103267     } catch (std::out_of_range& e) {
103268       {
103269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103270       };
103271     } catch (std::exception& e) {
103272       {
103273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103274       };
103275     } catch (...) {
103276       {
103277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103278       };
103279     }
103280   }
103281   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103282
103283   return jresult;
103284 }
103285
103286
103287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103288   void * jresult ;
103289   std::string *arg1 = 0 ;
103290   Dali::ImageDimensions arg2 ;
103291   Dali::FittingMode::Type arg3 ;
103292   Dali::SamplingMode::Type arg4 ;
103293   bool arg5 ;
103294   Dali::ImageDimensions *argp2 ;
103295   Dali::ImageDimensions result;
103296
103297   if (!jarg1) {
103298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103299     return 0;
103300   }
103301   std::string arg1_str(jarg1);
103302   arg1 = &arg1_str;
103303   argp2 = (Dali::ImageDimensions *)jarg2;
103304   if (!argp2) {
103305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103306     return 0;
103307   }
103308   arg2 = *argp2;
103309   arg3 = (Dali::FittingMode::Type)jarg3;
103310   arg4 = (Dali::SamplingMode::Type)jarg4;
103311   arg5 = jarg5 ? true : false;
103312   {
103313     try {
103314       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103315     } catch (std::out_of_range& e) {
103316       {
103317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103318       };
103319     } catch (std::exception& e) {
103320       {
103321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103322       };
103323     } catch (...) {
103324       {
103325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103326       };
103327     }
103328   }
103329   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103330
103331   return jresult;
103332 }
103333
103334
103335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103336   void * jresult ;
103337   std::string *arg1 = 0 ;
103338   Dali::ImageDimensions arg2 ;
103339   Dali::FittingMode::Type arg3 ;
103340   Dali::SamplingMode::Type arg4 ;
103341   Dali::ImageDimensions *argp2 ;
103342   Dali::ImageDimensions result;
103343
103344   if (!jarg1) {
103345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103346     return 0;
103347   }
103348   std::string arg1_str(jarg1);
103349   arg1 = &arg1_str;
103350   argp2 = (Dali::ImageDimensions *)jarg2;
103351   if (!argp2) {
103352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103353     return 0;
103354   }
103355   arg2 = *argp2;
103356   arg3 = (Dali::FittingMode::Type)jarg3;
103357   arg4 = (Dali::SamplingMode::Type)jarg4;
103358   {
103359     try {
103360       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
103361     } catch (std::out_of_range& e) {
103362       {
103363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103364       };
103365     } catch (std::exception& e) {
103366       {
103367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103368       };
103369     } catch (...) {
103370       {
103371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103372       };
103373     }
103374   }
103375   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103376
103377   return jresult;
103378 }
103379
103380
103381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103382   void * jresult ;
103383   std::string *arg1 = 0 ;
103384   Dali::ImageDimensions arg2 ;
103385   Dali::FittingMode::Type arg3 ;
103386   Dali::ImageDimensions *argp2 ;
103387   Dali::ImageDimensions result;
103388
103389   if (!jarg1) {
103390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103391     return 0;
103392   }
103393   std::string arg1_str(jarg1);
103394   arg1 = &arg1_str;
103395   argp2 = (Dali::ImageDimensions *)jarg2;
103396   if (!argp2) {
103397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103398     return 0;
103399   }
103400   arg2 = *argp2;
103401   arg3 = (Dali::FittingMode::Type)jarg3;
103402   {
103403     try {
103404       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
103405     } catch (std::out_of_range& e) {
103406       {
103407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103408       };
103409     } catch (std::exception& e) {
103410       {
103411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103412       };
103413     } catch (...) {
103414       {
103415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103416       };
103417     }
103418   }
103419   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103420
103421   return jresult;
103422 }
103423
103424
103425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
103426   void * jresult ;
103427   std::string *arg1 = 0 ;
103428   Dali::ImageDimensions arg2 ;
103429   Dali::ImageDimensions *argp2 ;
103430   Dali::ImageDimensions result;
103431
103432   if (!jarg1) {
103433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103434     return 0;
103435   }
103436   std::string arg1_str(jarg1);
103437   arg1 = &arg1_str;
103438   argp2 = (Dali::ImageDimensions *)jarg2;
103439   if (!argp2) {
103440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103441     return 0;
103442   }
103443   arg2 = *argp2;
103444   {
103445     try {
103446       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
103447     } catch (std::out_of_range& e) {
103448       {
103449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103450       };
103451     } catch (std::exception& e) {
103452       {
103453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103454       };
103455     } catch (...) {
103456       {
103457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103458       };
103459     }
103460   }
103461   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103462
103463   return jresult;
103464 }
103465
103466
103467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
103468   void * jresult ;
103469   std::string *arg1 = 0 ;
103470   Dali::ImageDimensions result;
103471
103472   if (!jarg1) {
103473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103474     return 0;
103475   }
103476   std::string arg1_str(jarg1);
103477   arg1 = &arg1_str;
103478   {
103479     try {
103480       result = Dali::GetClosestImageSize((std::string const &)*arg1);
103481     } catch (std::out_of_range& e) {
103482       {
103483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103484       };
103485     } catch (std::exception& e) {
103486       {
103487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103488       };
103489     } catch (...) {
103490       {
103491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103492       };
103493     }
103494   }
103495   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103496
103497   return jresult;
103498 }
103499
103500
103501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103502   void * jresult ;
103503   std::string *arg1 = 0 ;
103504   Dali::ImageDimensions arg2 ;
103505   Dali::FittingMode::Type arg3 ;
103506   Dali::SamplingMode::Type arg4 ;
103507   bool arg5 ;
103508   Dali::ImageDimensions *argp2 ;
103509   Dali::Devel::PixelBuffer result;
103510
103511   if (!jarg1) {
103512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103513     return 0;
103514   }
103515   std::string arg1_str(jarg1);
103516   arg1 = &arg1_str;
103517   argp2 = (Dali::ImageDimensions *)jarg2;
103518   if (!argp2) {
103519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103520     return 0;
103521   }
103522   arg2 = *argp2;
103523   arg3 = (Dali::FittingMode::Type)jarg3;
103524   arg4 = (Dali::SamplingMode::Type)jarg4;
103525   arg5 = jarg5 ? true : false;
103526   {
103527     try {
103528       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103529     } catch (std::out_of_range& e) {
103530       {
103531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103532       };
103533     } catch (std::exception& e) {
103534       {
103535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103536       };
103537     } catch (...) {
103538       {
103539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103540       };
103541     }
103542   }
103543   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103544
103545   return jresult;
103546 }
103547
103548
103549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103550   void * jresult ;
103551   std::string *arg1 = 0 ;
103552   Dali::ImageDimensions arg2 ;
103553   Dali::FittingMode::Type arg3 ;
103554   Dali::SamplingMode::Type arg4 ;
103555   Dali::ImageDimensions *argp2 ;
103556   Dali::Devel::PixelBuffer result;
103557
103558   if (!jarg1) {
103559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103560     return 0;
103561   }
103562   std::string arg1_str(jarg1);
103563   arg1 = &arg1_str;
103564   argp2 = (Dali::ImageDimensions *)jarg2;
103565   if (!argp2) {
103566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103567     return 0;
103568   }
103569   arg2 = *argp2;
103570   arg3 = (Dali::FittingMode::Type)jarg3;
103571   arg4 = (Dali::SamplingMode::Type)jarg4;
103572   {
103573     try {
103574       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
103575     } catch (std::out_of_range& e) {
103576       {
103577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103578       };
103579     } catch (std::exception& e) {
103580       {
103581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103582       };
103583     } catch (...) {
103584       {
103585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103586       };
103587     }
103588   }
103589   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103590
103591   return jresult;
103592 }
103593
103594
103595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103596   void * jresult ;
103597   std::string *arg1 = 0 ;
103598   Dali::ImageDimensions arg2 ;
103599   Dali::FittingMode::Type arg3 ;
103600   Dali::ImageDimensions *argp2 ;
103601   Dali::Devel::PixelBuffer result;
103602
103603   if (!jarg1) {
103604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103605     return 0;
103606   }
103607   std::string arg1_str(jarg1);
103608   arg1 = &arg1_str;
103609   argp2 = (Dali::ImageDimensions *)jarg2;
103610   if (!argp2) {
103611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103612     return 0;
103613   }
103614   arg2 = *argp2;
103615   arg3 = (Dali::FittingMode::Type)jarg3;
103616   {
103617     try {
103618       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
103619     } catch (std::out_of_range& e) {
103620       {
103621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103622       };
103623     } catch (std::exception& e) {
103624       {
103625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103626       };
103627     } catch (...) {
103628       {
103629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103630       };
103631     }
103632   }
103633   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103634
103635   return jresult;
103636 }
103637
103638
103639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
103640   void * jresult ;
103641   std::string *arg1 = 0 ;
103642   Dali::ImageDimensions arg2 ;
103643   Dali::ImageDimensions *argp2 ;
103644   Dali::Devel::PixelBuffer result;
103645
103646   if (!jarg1) {
103647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103648     return 0;
103649   }
103650   std::string arg1_str(jarg1);
103651   arg1 = &arg1_str;
103652   argp2 = (Dali::ImageDimensions *)jarg2;
103653   if (!argp2) {
103654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103655     return 0;
103656   }
103657   arg2 = *argp2;
103658   {
103659     try {
103660       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
103661     } catch (std::out_of_range& e) {
103662       {
103663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103664       };
103665     } catch (std::exception& e) {
103666       {
103667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103668       };
103669     } catch (...) {
103670       {
103671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103672       };
103673     }
103674   }
103675   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103676
103677   return jresult;
103678 }
103679
103680
103681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
103682   void * jresult ;
103683   std::string *arg1 = 0 ;
103684   Dali::Devel::PixelBuffer result;
103685
103686   if (!jarg1) {
103687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103688     return 0;
103689   }
103690   std::string arg1_str(jarg1);
103691   arg1 = &arg1_str;
103692   {
103693     try {
103694       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
103695     } catch (std::out_of_range& e) {
103696       {
103697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103698       };
103699     } catch (std::exception& e) {
103700       {
103701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103702       };
103703     } catch (...) {
103704       {
103705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103706       };
103707     }
103708   }
103709   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103710
103711   return jresult;
103712 }
103713
103714
103715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetMaxTextureSize(unsigned int jarg1) {
103716   unsigned int arg1 ;
103717
103718   arg1 = (unsigned int)jarg1;
103719   {
103720     try {
103721       Dali::SetMaxTextureSize(arg1);
103722     } catch (std::out_of_range& e) {
103723       {
103724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103725       };
103726     } catch (std::exception& e) {
103727       {
103728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103729       };
103730     } catch (...) {
103731       {
103732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103733       };
103734     }
103735   }
103736 }
103737
103738
103739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetMaxTextureSize() {
103740   unsigned int jresult ;
103741   unsigned int result;
103742
103743   {
103744     try {
103745       result = (unsigned int)Dali::GetMaxTextureSize();
103746     } catch (std::out_of_range& e) {
103747       {
103748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103749       };
103750     } catch (std::exception& e) {
103751       {
103752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103753       };
103754     } catch (...) {
103755       {
103756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103757       };
103758     }
103759   }
103760   jresult = result;
103761   return jresult;
103762 }
103763
103764
103765 #ifdef __cplusplus
103766 }
103767 #endif
103768